internal unsafe override int GetByteCount(char *chars, int charCount, EncoderNLS encoder)
{
char c = '\0';
char *ptr = chars + charCount;
EncoderFallbackBuffer encoderFallbackBuffer = null;
EncoderReplacementFallback encoderReplacementFallback;
if (encoder != null)
{
c = encoder.charLeftOver;
encoderReplacementFallback = (encoder.Fallback as EncoderReplacementFallback);
if (encoder.InternalHasFallbackBuffer)
{
encoderFallbackBuffer = encoder.FallbackBuffer;
if (encoderFallbackBuffer.Remaining > 0 && encoder.m_throwOnOverflow)
{
throw new ArgumentException(Environment.GetResourceString("Argument_EncoderFallbackNotEmpty", new object[]
{
this.EncodingName,
encoder.Fallback.GetType()
}));
}
encoderFallbackBuffer.InternalInitialize(chars, ptr, encoder, false);
}
}
else
{
encoderReplacementFallback = (base.EncoderFallback as EncoderReplacementFallback);
}
if (encoderReplacementFallback != null && encoderReplacementFallback.MaxCharCount == 1)
{
if (c > '\0')
{
charCount++;
}
return(charCount);
}
int num = 0;
if (c > '\0')
{
encoderFallbackBuffer = encoder.FallbackBuffer;
encoderFallbackBuffer.InternalInitialize(chars, ptr, encoder, false);
encoderFallbackBuffer.InternalFallback(c, ref chars);
}
char c2;
while ((c2 = ((encoderFallbackBuffer == null) ? '\0' : encoderFallbackBuffer.InternalGetNextChar())) != '\0' || chars < ptr)
{
if (c2 == '\0')
{
c2 = *chars;
chars++;
}
if (c2 > '\u007f')
{
if (encoderFallbackBuffer == null)
{
if (encoder == null)
{
encoderFallbackBuffer = this.encoderFallback.CreateFallbackBuffer();
}
else
{
encoderFallbackBuffer = encoder.FallbackBuffer;
}
encoderFallbackBuffer.InternalInitialize(ptr - charCount, ptr, encoder, false);
}
encoderFallbackBuffer.InternalFallback(c2, ref chars);
}
else
{
num++;
}
}
return(num);
}
// End of overridden methods which use EncodingForwarder
internal override unsafe int GetByteCount(char *chars, int count, EncoderNLS encoder)
{
Debug.Assert(chars != null, "[UTF32Encoding.GetByteCount]chars!=null");
Debug.Assert(count >= 0, "[UTF32Encoding.GetByteCount]count >=0");
char *end = chars + count;
char *charStart = chars;
int byteCount = 0;
char highSurrogate = '\0';
// For fallback we may need a fallback buffer
EncoderFallbackBuffer fallbackBuffer = null;
if (encoder != null)
{
highSurrogate = encoder.charLeftOver;
fallbackBuffer = encoder.FallbackBuffer;
// We mustn't have left over fallback data when counting
if (fallbackBuffer.Remaining > 0)
{
throw new ArgumentException(SR.Format(SR.Argument_EncoderFallbackNotEmpty,
this.EncodingName, encoder.Fallback.GetType()));
}
}
else
{
fallbackBuffer = this.encoderFallback.CreateFallbackBuffer();
}
// Set our internal fallback interesting things.
fallbackBuffer.InternalInitialize(charStart, end, encoder, false);
char ch;
TryAgain:
while (((ch = fallbackBuffer.InternalGetNextChar()) != 0) || chars < end)
{
// First unwind any fallback
if (ch == 0)
{
// No fallback, just get next char
ch = *chars;
chars++;
}
// Do we need a low surrogate?
if (highSurrogate != '\0')
{
//
// In previous char, we encounter a high surrogate, so we are expecting a low surrogate here.
//
if (Char.IsLowSurrogate(ch))
{
// They're all legal
highSurrogate = '\0';
//
// One surrogate pair will be translated into 4 bytes UTF32.
//
byteCount += 4;
continue;
}
// We are missing our low surrogate, decrement chars and fallback the high surrogate
// The high surrogate may have come from the encoder, but nothing else did.
Debug.Assert(chars > charStart,
"[UTF32Encoding.GetByteCount]Expected chars to have advanced if no low surrogate");
chars--;
// Do the fallback
fallbackBuffer.InternalFallback(highSurrogate, ref chars);
// We're going to fallback the old high surrogate.
highSurrogate = '\0';
continue;
}
// Do we have another high surrogate?
if (Char.IsHighSurrogate(ch))
{
//
// We'll have a high surrogate to check next time.
//
highSurrogate = ch;
continue;
}
// Check for illegal characters
if (Char.IsLowSurrogate(ch))
{
// We have a leading low surrogate, do the fallback
fallbackBuffer.InternalFallback(ch, ref chars);
// Try again with fallback buffer
continue;
}
// We get to add the character (4 bytes UTF32)
byteCount += 4;
}
// May have to do our last surrogate
if ((encoder == null || encoder.MustFlush) && highSurrogate > 0)
{
// We have to do the fallback for the lonely high surrogate
fallbackBuffer.InternalFallback(highSurrogate, ref chars);
highSurrogate = (char)0;
goto TryAgain;
}
// Check for overflows.
if (byteCount < 0)
{
throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_GetByteCountOverflow);
}
// Shouldn't have anything in fallback buffer for GetByteCount
// (don't have to check m_throwOnOverflow for count)
Debug.Assert(fallbackBuffer.Remaining == 0,
"[UTF32Encoding.GetByteCount]Expected empty fallback buffer at end");
// Return our count
return(byteCount);
}
internal override unsafe int GetBytes(char *chars, int charCount,
byte *bytes, int byteCount, EncoderNLS encoder)
{
Debug.Assert(chars != null, "[UTF32Encoding.GetBytes]chars!=null");
Debug.Assert(bytes != null, "[UTF32Encoding.GetBytes]bytes!=null");
Debug.Assert(byteCount >= 0, "[UTF32Encoding.GetBytes]byteCount >=0");
Debug.Assert(charCount >= 0, "[UTF32Encoding.GetBytes]charCount >=0");
char *charStart = chars;
char *charEnd = chars + charCount;
byte *byteStart = bytes;
byte *byteEnd = bytes + byteCount;
char highSurrogate = '\0';
// For fallback we may need a fallback buffer
EncoderFallbackBuffer fallbackBuffer = null;
if (encoder != null)
{
highSurrogate = encoder.charLeftOver;
fallbackBuffer = encoder.FallbackBuffer;
// We mustn't have left over fallback data when not converting
if (encoder.m_throwOnOverflow && fallbackBuffer.Remaining > 0)
{
throw new ArgumentException(SR.Format(SR.Argument_EncoderFallbackNotEmpty,
this.EncodingName, encoder.Fallback.GetType()));
}
}
else
{
fallbackBuffer = this.encoderFallback.CreateFallbackBuffer();
}
// Set our internal fallback interesting things.
fallbackBuffer.InternalInitialize(charStart, charEnd, encoder, true);
char ch;
TryAgain:
while (((ch = fallbackBuffer.InternalGetNextChar()) != 0) || chars < charEnd)
{
// First unwind any fallback
if (ch == 0)
{
// No fallback, just get next char
ch = *chars;
chars++;
}
// Do we need a low surrogate?
if (highSurrogate != '\0')
{
//
// In previous char, we encountered a high surrogate, so we are expecting a low surrogate here.
//
if (Char.IsLowSurrogate(ch))
{
// Is it a legal one?
uint iTemp = GetSurrogate(highSurrogate, ch);
highSurrogate = '\0';
//
// One surrogate pair will be translated into 4 bytes UTF32.
//
if (bytes + 3 >= byteEnd)
{
// Don't have 4 bytes
if (fallbackBuffer.bFallingBack)
{
fallbackBuffer.MovePrevious(); // Aren't using these 2 fallback chars
fallbackBuffer.MovePrevious();
}
else
{
// If we don't have enough room, then either we should've advanced a while
// or we should have bytes==byteStart and throw below
Debug.Assert(chars > charStart + 1 || bytes == byteStart,
"[UnicodeEncoding.GetBytes]Expected chars to have when no room to add surrogate pair");
chars -= 2; // Aren't using those 2 chars
}
ThrowBytesOverflow(encoder, bytes == byteStart); // Throw maybe (if no bytes written)
highSurrogate = (char)0; // Nothing left over (we backed up to start of pair if supplimentary)
break;
}
if (_bigEndian)
{
*(bytes++) = (byte)(0x00);
*(bytes++) = (byte)(iTemp >> 16); // Implies & 0xFF, which isn't needed cause high are all 0
*(bytes++) = (byte)(iTemp >> 8); // Implies & 0xFF
*(bytes++) = (byte)(iTemp); // Implies & 0xFF
}
else
{
*(bytes++) = (byte)(iTemp); // Implies & 0xFF
*(bytes++) = (byte)(iTemp >> 8); // Implies & 0xFF
*(bytes++) = (byte)(iTemp >> 16); // Implies & 0xFF, which isn't needed cause high are all 0
*(bytes++) = (byte)(0x00);
}
continue;
}
// We are missing our low surrogate, decrement chars and fallback the high surrogate
// The high surrogate may have come from the encoder, but nothing else did.
Debug.Assert(chars > charStart,
"[UTF32Encoding.GetBytes]Expected chars to have advanced if no low surrogate");
chars--;
// Do the fallback
fallbackBuffer.InternalFallback(highSurrogate, ref chars);
// We're going to fallback the old high surrogate.
highSurrogate = '\0';
continue;
}
// Do we have another high surrogate?, if so remember it
if (Char.IsHighSurrogate(ch))
{
//
// We'll have a high surrogate to check next time.
//
highSurrogate = ch;
continue;
}
// Check for illegal characters (low surrogate)
if (Char.IsLowSurrogate(ch))
{
// We have a leading low surrogate, do the fallback
fallbackBuffer.InternalFallback(ch, ref chars);
// Try again with fallback buffer
continue;
}
// We get to add the character, yippee.
if (bytes + 3 >= byteEnd)
{
// Don't have 4 bytes
if (fallbackBuffer.bFallingBack)
{
fallbackBuffer.MovePrevious(); // Aren't using this fallback char
}
else
{
// Must've advanced already
Debug.Assert(chars > charStart,
"[UTF32Encoding.GetBytes]Expected chars to have advanced if normal character");
chars--; // Aren't using this char
}
ThrowBytesOverflow(encoder, bytes == byteStart); // Throw maybe (if no bytes written)
break; // Didn't throw, stop
}
if (_bigEndian)
{
*(bytes++) = (byte)(0x00);
*(bytes++) = (byte)(0x00);
*(bytes++) = (byte)((uint)ch >> 8); // Implies & 0xFF
*(bytes++) = (byte)(ch); // Implies & 0xFF
}
else
{
*(bytes++) = (byte)(ch); // Implies & 0xFF
*(bytes++) = (byte)((uint)ch >> 8); // Implies & 0xFF
*(bytes++) = (byte)(0x00);
*(bytes++) = (byte)(0x00);
}
}
// May have to do our last surrogate
if ((encoder == null || encoder.MustFlush) && highSurrogate > 0)
{
// We have to do the fallback for the lonely high surrogate
fallbackBuffer.InternalFallback(highSurrogate, ref chars);
highSurrogate = (char)0;
goto TryAgain;
}
// Fix our encoder if we have one
Debug.Assert(highSurrogate == 0 || (encoder != null && !encoder.MustFlush),
"[UTF32Encoding.GetBytes]Expected encoder to be flushed.");
if (encoder != null)
{
// Remember our left over surrogate (or 0 if flushing)
encoder.charLeftOver = highSurrogate;
// Need # chars used
encoder.m_charsUsed = (int)(chars - charStart);
}
// return the new length
return((int)(bytes - byteStart));
}
[System.Security.SecurityCritical] // auto-generated
internal override unsafe int GetBytes(char *chars, int charCount,
byte *bytes, int byteCount, EncoderNLS encoder)
{
// Just need to ASSERT, this is called by something else internal that checked parameters already
Contract.Assert(bytes != null, "[ASCIIEncoding.GetBytes]bytes is null");
Contract.Assert(byteCount >= 0, "[ASCIIEncoding.GetBytes]byteCount is negative");
Contract.Assert(chars != null, "[ASCIIEncoding.GetBytes]chars is null");
Contract.Assert(charCount >= 0, "[ASCIIEncoding.GetBytes]charCount is negative");
// Assert because we shouldn't be able to have a null encoder.
Contract.Assert(encoderFallback != null, "[ASCIIEncoding.GetBytes]Attempting to use null encoder fallback");
// Get any left over characters
char charLeftOver = (char)0;
EncoderReplacementFallback fallback = null;
// For fallback we may need a fallback buffer, we know we aren't default fallback.
EncoderFallbackBuffer fallbackBuffer = null;
// prepare our end
char *charEnd = chars + charCount;
byte *byteStart = bytes;
char *charStart = chars;
if (encoder != null)
{
charLeftOver = encoder.charLeftOver;
fallback = encoder.Fallback as EncoderReplacementFallback;
// We mustn't have left over fallback data when counting
if (encoder.InternalHasFallbackBuffer)
{
// We always need the fallback buffer in get bytes so we can flush any remaining ones if necessary
fallbackBuffer = encoder.FallbackBuffer;
if (fallbackBuffer.Remaining > 0 && encoder.m_throwOnOverflow)
{
throw new ArgumentException(SR.Format(SR.Argument_EncoderFallbackNotEmpty,
this.EncodingName, encoder.Fallback.GetType()));
}
// Set our internal fallback interesting things.
fallbackBuffer.InternalInitialize(charStart, charEnd, encoder, true);
}
Contract.Assert(charLeftOver == 0 || Char.IsHighSurrogate(charLeftOver),
"[ASCIIEncoding.GetBytes]leftover character should be high surrogate");
// Verify that we have no fallbackbuffer, for ASCII its always empty, so just assert
Contract.Assert(!encoder.m_throwOnOverflow || !encoder.InternalHasFallbackBuffer ||
encoder.FallbackBuffer.Remaining == 0,
"[ASCIICodePageEncoding.GetBytes]Expected empty fallback buffer");
// if (encoder.m_throwOnOverflow && encoder.InternalHasFallbackBuffer &&
// encoder.FallbackBuffer.Remaining > 0)
// throw new ArgumentException(SR.FormatSR.Argument_EncoderFallbackNotEmpty,
// this.EncodingName, encoder.Fallback.GetType()));
}
else
{
fallback = this.EncoderFallback as EncoderReplacementFallback;
}
// See if we do the fast default or slightly slower fallback
if (fallback != null && fallback.MaxCharCount == 1)
{
// Fast version
char cReplacement = fallback.DefaultString[0];
// Check for replacements in range, otherwise fall back to slow version.
if (cReplacement <= (char)0x7f)
{
// We should have exactly as many output bytes as input bytes, unless there's a left
// over character, in which case we may need one more.
// If we had a left over character will have to add a ? (This happens if they had a funky
// fallback last time, but not this time.) (We can't spit any out though
// because with fallback encoder each surrogate is treated as a seperate code point)
if (charLeftOver > 0)
{
// Have to have room
// Throw even if doing no throw version because this is just 1 char,
// so buffer will never be big enough
if (byteCount == 0)
{
ThrowBytesOverflow(encoder, true);
}
// This'll make sure we still have more room and also make sure our return value is correct.
*(bytes++) = (byte)cReplacement;
byteCount--; // We used one of the ones we were counting.
}
// This keeps us from overrunning our output buffer
if (byteCount < charCount)
{
// Throw or make buffer smaller?
ThrowBytesOverflow(encoder, byteCount < 1);
// Just use what we can
charEnd = chars + byteCount;
}
// We just do a quick copy
while (chars < charEnd)
{
char ch2 = *(chars++);
if (ch2 >= 0x0080)
{
*(bytes++) = (byte)cReplacement;
}
else
{
*(bytes++) = unchecked ((byte)(ch2));
}
}
// Clear encoder
if (encoder != null)
{
encoder.charLeftOver = (char)0;
encoder.m_charsUsed = (int)(chars - charStart);
}
return((int)(bytes - byteStart));
}
}
// Slower version, have to do real fallback.
// prepare our end
byte *byteEnd = bytes + byteCount;
// We may have a left over character from last time, try and process it.
if (charLeftOver > 0)
{
// Initialize the buffer
Contract.Assert(encoder != null,
"[ASCIIEncoding.GetBytes]Expected non null encoder if we have surrogate left over");
fallbackBuffer = encoder.FallbackBuffer;
fallbackBuffer.InternalInitialize(chars, charEnd, encoder, true);
// Since left over char was a surrogate, it'll have to be fallen back.
// Get Fallback
// This will fallback a pair if *chars is a low surrogate
fallbackBuffer.InternalFallback(charLeftOver, ref chars);
}
// Now we may have fallback char[] already from the encoder
// Go ahead and do it, including the fallback.
char ch;
while ((ch = (fallbackBuffer == null) ? '\0' : fallbackBuffer.InternalGetNextChar()) != 0 ||
chars < charEnd)
{
// First unwind any fallback
if (ch == 0)
{
// No fallback, just get next char
ch = *chars;
chars++;
}
// Check for fallback, this'll catch surrogate pairs too.
// All characters >= 0x80 must fall back.
if (ch > 0x7f)
{
// Initialize the buffer
if (fallbackBuffer == null)
{
if (encoder == null)
{
fallbackBuffer = this.encoderFallback.CreateFallbackBuffer();
}
else
{
fallbackBuffer = encoder.FallbackBuffer;
}
fallbackBuffer.InternalInitialize(charEnd - charCount, charEnd, encoder, true);
}
// Get Fallback
fallbackBuffer.InternalFallback(ch, ref chars);
// Go ahead & continue (& do the fallback)
continue;
}
// We'll use this one
// Bounds check
if (bytes >= byteEnd)
{
// didn't use this char, we'll throw or use buffer
if (fallbackBuffer == null || fallbackBuffer.bFallingBack == false)
{
Contract.Assert(chars > charStart || bytes == byteStart,
"[ASCIIEncoding.GetBytes]Expected chars to have advanced already.");
chars--; // don't use last char
}
else
{
fallbackBuffer.MovePrevious();
}
// Are we throwing or using buffer?
ThrowBytesOverflow(encoder, bytes == byteStart); // throw?
break; // don't throw, stop
}
// Go ahead and add it
*bytes = unchecked ((byte)ch);
bytes++;
}
// Need to do encoder stuff
if (encoder != null)
{
// Fallback stuck it in encoder if necessary, but we have to clear MustFlush cases
if (fallbackBuffer != null && !fallbackBuffer.bUsedEncoder)
{
// Clear it in case of MustFlush
encoder.charLeftOver = (char)0;
}
// Set our chars used count
encoder.m_charsUsed = (int)(chars - charStart);
}
Contract.Assert(fallbackBuffer == null || fallbackBuffer.Remaining == 0 ||
(encoder != null && !encoder.m_throwOnOverflow),
"[ASCIIEncoding.GetBytes]Expected Empty fallback buffer at end");
return((int)(bytes - byteStart));
}
internal override unsafe int GetBytes(char *chars, int charCount,
byte *bytes, int byteCount, EncoderNLS encoder)
{
// Just need to ASSERT, this is called by something else internal that checked parameters already
BCLDebug.Assert(bytes != null, "[SBCSCodePageEncoding.GetBytes]bytes is null");
BCLDebug.Assert(byteCount >= 0, "[SBCSCodePageEncoding.GetBytes]byteCount is negative");
BCLDebug.Assert(chars != null, "[SBCSCodePageEncoding.GetBytes]chars is null");
BCLDebug.Assert(charCount >= 0, "[SBCSCodePageEncoding.GetBytes]charCount is negative");
// Assert because we shouldn't be able to have a null encoder.
BCLDebug.Assert(encoderFallback != null, "[SBCSCodePageEncoding.GetBytes]Attempting to use null encoder fallback");
CheckMemorySection();
// Need to test fallback
EncoderReplacementFallback fallback = null;
// Get any left over characters
char charLeftOver = (char)0;
if (encoder != null)
{
charLeftOver = encoder.charLeftOver;
BCLDebug.Assert(charLeftOver == 0 || Char.IsHighSurrogate(charLeftOver),
"[SBCSCodePageEncoding.GetBytes]leftover character should be high surrogate");
fallback = encoder.Fallback as EncoderReplacementFallback;
// Verify that we have no fallbackbuffer, for SBCS its always empty, so just assert
BCLDebug.Assert(!encoder.m_throwOnOverflow || !encoder.InternalHasFallbackBuffer ||
encoder.FallbackBuffer.Remaining == 0,
"[SBCSCodePageEncoding.GetBytes]Expected empty fallback buffer at start");
// if (encoder.m_throwOnOverflow && encoder.InternalHasFallbackBuffer &&
// encoder.FallbackBuffer.Remaining > 0)
// throw new ArgumentException(Environment.GetResourceString("Argument_EncoderFallbackNotEmpty",
// this.EncodingName, encoder.Fallback.GetType()));
}
else
{
// If we aren't using default fallback then we may have a complicated count.
fallback = this.EncoderFallback as EncoderReplacementFallback;
}
// prepare our end
char *charEnd = chars + charCount;
byte *byteStart = bytes;
char *charStart = chars;
// See if we do the fast default or slightly slower fallback
if (fallback != null && fallback.MaxCharCount == 1)
{
// Make sure our fallback character is valid first
byte bReplacement = mapUnicodeToBytes[fallback.DefaultString[0]];
// Check for replacements in range, otherwise fall back to slow version.
if (bReplacement != 0)
{
// We should have exactly as many output bytes as input bytes, unless there's a left
// over character, in which case we may need one more.
// If we had a left over character will have to add a ? (This happens if they had a funky
// fallback last time, but not this time.) (We can't spit any out though
// because with fallback encoder each surrogate is treated as a seperate code point)
if (charLeftOver > 0)
{
// Have to have room
// Throw even if doing no throw version because this is just 1 char,
// so buffer will never be big enough
if (byteCount == 0)
{
ThrowBytesOverflow(encoder, true);
}
// This'll make sure we still have more room and also make sure our return value is correct.
*(bytes++) = bReplacement;
byteCount--; // We used one of the ones we were counting.
}
// This keeps us from overrunning our output buffer
if (byteCount < charCount)
{
// Throw or make buffer smaller?
ThrowBytesOverflow(encoder, byteCount < 1);
// Just use what we can
charEnd = chars + byteCount;
}
// Simple way
while (chars < charEnd)
{
char ch2 = *chars;
chars++;
byte bTemp = mapUnicodeToBytes[ch2];
// Check for fallback
if (bTemp == 0 && ch2 != (char)0)
{
*bytes = bReplacement;
}
else
{
*bytes = bTemp;
}
bytes++;
}
// Clear encoder
if (encoder != null)
{
encoder.charLeftOver = (char)0;
encoder.m_charsUsed = (int)(chars - charStart);
}
return((int)(bytes - byteStart));
}
}
// Slower version, have to do real fallback.
// For fallback we may need a fallback buffer, we know we aren't default fallback
EncoderFallbackBuffer fallbackBuffer = null;
// prepare our end
byte *byteEnd = bytes + byteCount;
// We may have a left over character from last time, try and process it.
if (charLeftOver > 0)
{
// Since left over char was a surrogate, it'll have to be fallen back.
// Get Fallback
BCLDebug.Assert(encoder != null, "[SBCSCodePageEncoding.GetBytes]Expect to have encoder if we have a charLeftOver");
fallbackBuffer = encoder.FallbackBuffer;
fallbackBuffer.InternalInitialize(chars, charEnd, encoder, true);
// This will fallback a pair if *chars is a low surrogate
fallbackBuffer.InternalFallback(charLeftOver, ref chars);
if (fallbackBuffer.Remaining > byteEnd - bytes)
{
// Throw it, if we don't have enough for this we never will
ThrowBytesOverflow(encoder, true);
}
}
// Now we may have fallback char[] already from the encoder fallback above
// Go ahead and do it, including the fallback.
char ch;
while ((ch = (fallbackBuffer == null) ? '\0' : fallbackBuffer.InternalGetNextChar()) != 0 ||
chars < charEnd)
{
// First unwind any fallback
if (ch == 0)
{
// No fallback, just get next char
ch = *chars;
chars++;
}
// get byte for this char
byte bTemp = mapUnicodeToBytes[ch];
// Check for fallback, this'll catch surrogate pairs too.
if (bTemp == 0 && ch != (char)0)
{
// Get Fallback
if (fallbackBuffer == null)
{
// Create & init fallback buffer
if (encoder == null)
{
fallbackBuffer = this.encoderFallback.CreateFallbackBuffer();
}
else
{
fallbackBuffer = encoder.FallbackBuffer;
}
// chars has moved so we need to remember figure it out so Exception fallback
// index will be correct
fallbackBuffer.InternalInitialize(charEnd - charCount, charEnd, encoder, true);
}
// Make sure we have enough room. Each fallback char will be 1 output char
// (or recursion exception will be thrown)
fallbackBuffer.InternalFallback(ch, ref chars);
if (fallbackBuffer.Remaining > byteEnd - bytes)
{
// Didn't use this char, reset it
BCLDebug.Assert(chars > charStart,
"[SBCSCodePageEncoding.GetBytes]Expected chars to have advanced (fallback)");
chars--;
fallbackBuffer.InternalReset();
// Throw it & drop this data
ThrowBytesOverflow(encoder, chars == charStart);
break;
}
continue;
}
// We'll use this one
// Bounds check
if (bytes >= byteEnd)
{
// didn't use this char, we'll throw or use buffer
BCLDebug.Assert(fallbackBuffer == null || fallbackBuffer.bFallingBack == false,
"[SBCSCodePageEncoding.GetBytes]Expected to NOT be falling back");
if (fallbackBuffer == null || fallbackBuffer.bFallingBack == false)
{
BCLDebug.Assert(chars > charStart,
"[SBCSCodePageEncoding.GetBytes]Expected chars to have advanced (normal)");
chars--; // don't use last char
}
ThrowBytesOverflow(encoder, chars == charStart); // throw ?
break; // don't throw, stop
}
// Go ahead and add it
*bytes = bTemp;
bytes++;
}
// encoder stuff if we have one
if (encoder != null)
{
// Fallback stuck it in encoder if necessary, but we have to clear MustFlush cases
if (fallbackBuffer != null && !fallbackBuffer.bUsedEncoder)
{
// Clear it in case of MustFlush
encoder.charLeftOver = (char)0;
}
// Set our chars used count
encoder.m_charsUsed = (int)(chars - charStart);
}
// Expect Empty fallback buffer for SBCS
BCLDebug.Assert(fallbackBuffer == null || fallbackBuffer.Remaining == 0,
"[SBCSEncoding.GetBytes]Expected Empty fallback buffer at end");
return((int)(bytes - byteStart));
}
internal override unsafe int GetBytes(char *chars, int charCount, byte *bytes, int byteCount, EncoderNLS encoder)
{
char ch1 = char.MinValue;
EncoderFallbackBuffer encoderFallbackBuffer = (EncoderFallbackBuffer)null;
char *charEnd = chars + charCount;
byte *numPtr1 = bytes;
char *charStart = chars;
EncoderReplacementFallback replacementFallback;
if (encoder != null)
{
ch1 = encoder.charLeftOver;
replacementFallback = encoder.Fallback as EncoderReplacementFallback;
if (encoder.InternalHasFallbackBuffer)
{
encoderFallbackBuffer = encoder.FallbackBuffer;
if (encoderFallbackBuffer.Remaining > 0 && encoder.m_throwOnOverflow)
{
throw new ArgumentException(Environment.GetResourceString("Argument_EncoderFallbackNotEmpty", (object)this.EncodingName, (object)encoder.Fallback.GetType()));
}
encoderFallbackBuffer.InternalInitialize(charStart, charEnd, encoder, true);
}
}
else
{
replacementFallback = this.EncoderFallback as EncoderReplacementFallback;
}
if (replacementFallback != null && replacementFallback.MaxCharCount == 1)
{
char ch2 = replacementFallback.DefaultString[0];
if ((int)ch2 <= (int)sbyte.MaxValue)
{
if ((int)ch1 > 0)
{
if (byteCount == 0)
{
this.ThrowBytesOverflow(encoder, true);
}
*bytes++ = (byte)ch2;
--byteCount;
}
if (byteCount < charCount)
{
this.ThrowBytesOverflow(encoder, byteCount < 1);
charEnd = chars + byteCount;
}
while (chars < charEnd)
{
char ch3 = *chars++;
* bytes++ = (int)ch3 < 128 ? (byte)ch3 : (byte)ch2;
}
if (encoder != null)
{
encoder.charLeftOver = char.MinValue;
encoder.m_charsUsed = (int)(chars - charStart);
}
return((int)(bytes - numPtr1));
}
}
byte *numPtr2 = bytes + byteCount;
if ((int)ch1 > 0)
{
encoderFallbackBuffer = encoder.FallbackBuffer;
encoderFallbackBuffer.InternalInitialize(chars, charEnd, encoder, true);
encoderFallbackBuffer.InternalFallback(ch1, ref chars);
}
char ch4;
while ((int)(ch4 = encoderFallbackBuffer == null ? char.MinValue : encoderFallbackBuffer.InternalGetNextChar()) != 0 || chars < charEnd)
{
if ((int)ch4 == 0)
{
ch4 = *chars;
chars += 2;
}
if ((int)ch4 > (int)sbyte.MaxValue)
{
if (encoderFallbackBuffer == null)
{
encoderFallbackBuffer = encoder != null ? encoder.FallbackBuffer : this.encoderFallback.CreateFallbackBuffer();
encoderFallbackBuffer.InternalInitialize(charEnd - charCount, charEnd, encoder, true);
}
encoderFallbackBuffer.InternalFallback(ch4, ref chars);
}
else
{
if (bytes >= numPtr2)
{
if (encoderFallbackBuffer == null || !encoderFallbackBuffer.bFallingBack)
{
chars -= 2;
}
else
{
encoderFallbackBuffer.MovePrevious();
}
this.ThrowBytesOverflow(encoder, bytes == numPtr1);
break;
}
*bytes = (byte)ch4;
++bytes;
}
}
if (encoder != null)
{
if (encoderFallbackBuffer != null && !encoderFallbackBuffer.bUsedEncoder)
{
encoder.charLeftOver = char.MinValue;
}
encoder.m_charsUsed = (int)(chars - charStart);
}
return((int)(bytes - numPtr1));
}
[System.Security.SecurityCritical] // auto-generated
internal override unsafe int GetByteCount(char *chars, int charCount, EncoderNLS encoder)
{
// Just need to ASSERT, this is called by something else internal that checked parameters already
Contract.Assert(charCount >= 0, "[ASCIIEncoding.GetByteCount]count is negative");
Contract.Assert(chars != null, "[ASCIIEncoding.GetByteCount]chars is null");
// Assert because we shouldn't be able to have a null encoder.
Contract.Assert(encoderFallback != null, "[ASCIIEncoding.GetByteCount]Attempting to use null fallback encoder");
char charLeftOver = (char)0;
EncoderReplacementFallback fallback = null;
// Start by assuming default count, then +/- for fallback characters
char *charEnd = chars + charCount;
// For fallback we may need a fallback buffer, we know we aren't default fallback.
EncoderFallbackBuffer fallbackBuffer = null;
if (encoder != null)
{
charLeftOver = encoder.charLeftOver;
Contract.Assert(charLeftOver == 0 || Char.IsHighSurrogate(charLeftOver),
"[ASCIIEncoding.GetByteCount]leftover character should be high surrogate");
fallback = encoder.Fallback as EncoderReplacementFallback;
// We mustn't have left over fallback data when counting
if (encoder.InternalHasFallbackBuffer)
{
// We always need the fallback buffer in get bytes so we can flush any remaining ones if necessary
fallbackBuffer = encoder.FallbackBuffer;
if (fallbackBuffer.Remaining > 0 && encoder.m_throwOnOverflow)
{
throw new ArgumentException(SR.Format(SR.Argument_EncoderFallbackNotEmpty,
this.EncodingName, encoder.Fallback.GetType()));
}
// Set our internal fallback interesting things.
fallbackBuffer.InternalInitialize(chars, charEnd, encoder, false);
}
// Verify that we have no fallbackbuffer, for ASCII its always empty, so just assert
Contract.Assert(!encoder.m_throwOnOverflow || !encoder.InternalHasFallbackBuffer ||
encoder.FallbackBuffer.Remaining == 0,
"[ASCIICodePageEncoding.GetByteCount]Expected empty fallback buffer");
// if (encoder.InternalHasFallbackBuffer && encoder.FallbackBuffer.Remaining > 0)
// throw new ArgumentException(SR.FormatSR.Argument_EncoderFallbackNotEmpty,
// this.EncodingName, encoder.Fallback.GetType()));
}
else
{
fallback = this.EncoderFallback as EncoderReplacementFallback;
}
// If we have an encoder AND we aren't using default fallback,
// then we may have a complicated count.
if (fallback != null && fallback.MaxCharCount == 1)
{
// Replacement fallback encodes surrogate pairs as two ?? (or two whatever), so return size is always
// same as input size.
// Note that no existing SBCS code pages map code points to supplimentary characters, so this is easy.
// We could however have 1 extra byte if the last call had an encoder and a funky fallback and
// if we don't use the funky fallback this time.
// Do we have an extra char left over from last time?
if (charLeftOver > 0)
{
charCount++;
}
return(charCount);
}
// Count is more complicated if you have a funky fallback
// For fallback we may need a fallback buffer, we know we're not default fallback
int byteCount = 0;
// We may have a left over character from last time, try and process it.
if (charLeftOver > 0)
{
Contract.Assert(Char.IsHighSurrogate(charLeftOver), "[ASCIIEncoding.GetByteCount]leftover character should be high surrogate");
Contract.Assert(encoder != null, "[ASCIIEncoding.GetByteCount]Expected encoder");
// Since left over char was a surrogate, it'll have to be fallen back.
// Get Fallback
fallbackBuffer = encoder.FallbackBuffer;
fallbackBuffer.InternalInitialize(chars, charEnd, encoder, false);
// This will fallback a pair if *chars is a low surrogate
fallbackBuffer.InternalFallback(charLeftOver, ref chars);
}
// Now we may have fallback char[] already from the encoder
// Go ahead and do it, including the fallback.
char ch;
while ((ch = (fallbackBuffer == null) ? '\0' : fallbackBuffer.InternalGetNextChar()) != 0 ||
chars < charEnd)
{
// First unwind any fallback
if (ch == 0)
{
// No fallback, just get next char
ch = *chars;
chars++;
}
// Check for fallback, this'll catch surrogate pairs too.
// no chars >= 0x80 are allowed.
if (ch > 0x7f)
{
if (fallbackBuffer == null)
{
// Initialize the buffer
if (encoder == null)
{
fallbackBuffer = this.encoderFallback.CreateFallbackBuffer();
}
else
{
fallbackBuffer = encoder.FallbackBuffer;
}
fallbackBuffer.InternalInitialize(charEnd - charCount, charEnd, encoder, false);
}
// Get Fallback
fallbackBuffer.InternalFallback(ch, ref chars);
continue;
}
// We'll use this one
byteCount++;
}
Contract.Assert(fallbackBuffer == null || fallbackBuffer.Remaining == 0,
"[ASCIIEncoding.GetByteCount]Expected Empty fallback buffer");
return(byteCount);
}
internal unsafe override int GetBytes(char *chars, int charCount, byte *bytes, int byteCount, EncoderNLS encoder)
{
base.CheckMemorySection();
EncoderFallbackBuffer encoderFallbackBuffer = null;
char *ptr = chars + charCount;
char *ptr2 = chars;
byte *ptr3 = bytes;
byte *ptr4 = bytes + byteCount;
if (encoder != null)
{
char charLeftOver = encoder.charLeftOver;
encoderFallbackBuffer = encoder.FallbackBuffer;
encoderFallbackBuffer.InternalInitialize(chars, ptr, encoder, true);
if (encoder.m_throwOnOverflow && encoderFallbackBuffer.Remaining > 0)
{
throw new ArgumentException(Environment.GetResourceString("Argument_EncoderFallbackNotEmpty", new object[]
{
this.EncodingName,
encoder.Fallback.GetType()
}));
}
if (charLeftOver > '\0')
{
encoderFallbackBuffer.InternalFallback(charLeftOver, ref chars);
}
}
char c;
while ((c = ((encoderFallbackBuffer == null) ? '\0' : encoderFallbackBuffer.InternalGetNextChar())) != '\0' || chars < ptr)
{
if (c == '\0')
{
c = *chars;
chars++;
}
ushort num = this.mapUnicodeToBytes[(IntPtr)c];
if (num == 0 && c != '\0')
{
if (encoderFallbackBuffer == null)
{
encoderFallbackBuffer = this.encoderFallback.CreateFallbackBuffer();
encoderFallbackBuffer.InternalInitialize(ptr - charCount, ptr, encoder, true);
}
encoderFallbackBuffer.InternalFallback(c, ref chars);
}
else
{
if (num >= 256)
{
if (bytes + 1 >= ptr4)
{
if (encoderFallbackBuffer == null || !encoderFallbackBuffer.bFallingBack)
{
chars--;
}
else
{
encoderFallbackBuffer.MovePrevious();
}
base.ThrowBytesOverflow(encoder, chars == ptr2);
break;
}
*bytes = (byte)(num >> 8);
bytes++;
}
else if (bytes >= ptr4)
{
if (encoderFallbackBuffer == null || !encoderFallbackBuffer.bFallingBack)
{
chars--;
}
else
{
encoderFallbackBuffer.MovePrevious();
}
base.ThrowBytesOverflow(encoder, chars == ptr2);
break;
}
*bytes = (byte)(num & 255);
bytes++;
}
}
if (encoder != null)
{
if (encoderFallbackBuffer != null && !encoderFallbackBuffer.bUsedEncoder)
{
encoder.charLeftOver = '\0';
}
encoder.m_charsUsed = (int)((long)(chars - ptr2));
}
return((int)((long)(bytes - ptr3)));
}
internal unsafe override int GetBytes(char *chars, int charCount, byte *bytes, int byteCount, EncoderNLS encoder)
{
char c = '\0';
EncoderReplacementFallback encoderReplacementFallback;
if (encoder != null)
{
c = encoder.charLeftOver;
encoderReplacementFallback = (encoder.Fallback as EncoderReplacementFallback);
}
else
{
encoderReplacementFallback = (base.EncoderFallback as EncoderReplacementFallback);
}
char *ptr = chars + charCount;
byte *ptr2 = bytes;
char *ptr3 = chars;
if (encoderReplacementFallback != null && encoderReplacementFallback.MaxCharCount == 1)
{
char c2 = encoderReplacementFallback.DefaultString[0];
if (c2 <= 'ÿ')
{
if (c > '\0')
{
if (byteCount == 0)
{
base.ThrowBytesOverflow(encoder, true);
}
*(bytes++) = (byte)c2;
byteCount--;
}
if (byteCount < charCount)
{
base.ThrowBytesOverflow(encoder, byteCount < 1);
ptr = chars + byteCount;
}
while (chars < ptr)
{
char c3 = *(chars++);
if (c3 > 'ÿ')
{
*(bytes++) = (byte)c2;
}
else
{
*(bytes++) = (byte)c3;
}
}
if (encoder != null)
{
encoder.charLeftOver = '\0';
encoder.m_charsUsed = (int)((long)(chars - ptr3));
}
return((int)((long)(bytes - ptr2)));
}
}
byte *ptr4 = bytes + byteCount;
EncoderFallbackBuffer encoderFallbackBuffer = null;
if (c > '\0')
{
encoderFallbackBuffer = encoder.FallbackBuffer;
encoderFallbackBuffer.InternalInitialize(chars, ptr, encoder, true);
encoderFallbackBuffer.InternalFallback(c, ref chars);
if ((long)encoderFallbackBuffer.Remaining > (long)(ptr4 - bytes))
{
base.ThrowBytesOverflow(encoder, true);
}
}
char c4;
while ((c4 = ((encoderFallbackBuffer == null) ? '\0' : encoderFallbackBuffer.InternalGetNextChar())) != '\0' || chars < ptr)
{
if (c4 == '\0')
{
c4 = *chars;
chars++;
}
if (c4 > 'ÿ')
{
if (encoderFallbackBuffer == null)
{
if (encoder == null)
{
encoderFallbackBuffer = this.encoderFallback.CreateFallbackBuffer();
}
else
{
encoderFallbackBuffer = encoder.FallbackBuffer;
}
encoderFallbackBuffer.InternalInitialize(ptr - charCount, ptr, encoder, true);
}
encoderFallbackBuffer.InternalFallback(c4, ref chars);
if ((long)encoderFallbackBuffer.Remaining > (long)(ptr4 - bytes))
{
chars--;
encoderFallbackBuffer.InternalReset();
base.ThrowBytesOverflow(encoder, chars == ptr3);
break;
}
}
else
{
if (bytes >= ptr4)
{
if (encoderFallbackBuffer == null || !encoderFallbackBuffer.bFallingBack)
{
chars--;
}
base.ThrowBytesOverflow(encoder, chars == ptr3);
break;
}
*bytes = (byte)c4;
bytes++;
}
}
if (encoder != null)
{
if (encoderFallbackBuffer != null && !encoderFallbackBuffer.bUsedEncoder)
{
encoder.charLeftOver = '\0';
}
encoder.m_charsUsed = (int)((long)(chars - ptr3));
}
return((int)((long)(bytes - ptr2)));
}
internal override unsafe int GetByteCount(char* chars, int charCount, EncoderNLS encoder)
{
EncoderReplacementFallback encoderFallback;
char ch2;
char charLeftOver = '\0';
if (encoder != null)
{
charLeftOver = encoder.charLeftOver;
encoderFallback = encoder.Fallback as EncoderReplacementFallback;
}
else
{
encoderFallback = base.EncoderFallback as EncoderReplacementFallback;
}
if ((encoderFallback != null) && (encoderFallback.MaxCharCount == 1))
{
if (charLeftOver > '\0')
{
charCount++;
}
return charCount;
}
int num = 0;
char* charEnd = chars + charCount;
EncoderFallbackBuffer fallbackBuffer = null;
if (charLeftOver > '\0')
{
fallbackBuffer = encoder.FallbackBuffer;
fallbackBuffer.InternalInitialize(chars, charEnd, encoder, false);
fallbackBuffer.InternalFallback(charLeftOver, ref chars);
}
while (((ch2 = (fallbackBuffer == null) ? '\0' : fallbackBuffer.InternalGetNextChar()) != '\0') || (chars < charEnd))
{
if (ch2 == '\0')
{
ch2 = chars[0];
chars++;
}
if (ch2 > '\x00ff')
{
if (fallbackBuffer == null)
{
if (encoder == null)
{
fallbackBuffer = base.encoderFallback.CreateFallbackBuffer();
}
else
{
fallbackBuffer = encoder.FallbackBuffer;
}
fallbackBuffer.InternalInitialize(charEnd - charCount, charEnd, encoder, false);
}
fallbackBuffer.InternalFallback(ch2, ref chars);
}
else
{
num++;
}
}
return num;
}
internal unsafe override int GetByteCount(char *chars, int count, EncoderNLS encoder)
{
base.CheckMemorySection();
char c = '\0';
if (encoder != null)
{
c = encoder.charLeftOver;
if (encoder.InternalHasFallbackBuffer && encoder.FallbackBuffer.Remaining > 0)
{
throw new ArgumentException(Environment.GetResourceString("Argument_EncoderFallbackNotEmpty", new object[]
{
this.EncodingName,
encoder.Fallback.GetType()
}));
}
}
int num = 0;
char *ptr = chars + count;
EncoderFallbackBuffer encoderFallbackBuffer = null;
if (c > '\0')
{
encoderFallbackBuffer = encoder.FallbackBuffer;
encoderFallbackBuffer.InternalInitialize(chars, ptr, encoder, false);
encoderFallbackBuffer.InternalFallback(c, ref chars);
}
char c2;
while ((c2 = ((encoderFallbackBuffer == null) ? '\0' : encoderFallbackBuffer.InternalGetNextChar())) != '\0' || chars < ptr)
{
if (c2 == '\0')
{
c2 = *chars;
chars++;
}
ushort num2 = this.mapUnicodeToBytes[(IntPtr)c2];
if (num2 == 0 && c2 != '\0')
{
if (encoderFallbackBuffer == null)
{
if (encoder == null)
{
encoderFallbackBuffer = this.encoderFallback.CreateFallbackBuffer();
}
else
{
encoderFallbackBuffer = encoder.FallbackBuffer;
}
encoderFallbackBuffer.InternalInitialize(ptr - count, ptr, encoder, false);
}
encoderFallbackBuffer.InternalFallback(c2, ref chars);
}
else
{
num++;
if (num2 >= 256)
{
num++;
}
}
}
return(num);
}
internal override unsafe int GetBytes(char* chars, int charCount, byte* bytes, int byteCount, EncoderNLS encoder)
{
char ch4;
char charLeftOver = '\0';
EncoderReplacementFallback encoderFallback = null;
if (encoder != null)
{
charLeftOver = encoder.charLeftOver;
encoderFallback = encoder.Fallback as EncoderReplacementFallback;
}
else
{
encoderFallback = base.EncoderFallback as EncoderReplacementFallback;
}
char* charEnd = chars + charCount;
byte* numPtr = bytes;
char* chPtr2 = chars;
if ((encoderFallback != null) && (encoderFallback.MaxCharCount == 1))
{
char ch2 = encoderFallback.DefaultString[0];
if (ch2 <= '\x00ff')
{
if (charLeftOver > '\0')
{
if (byteCount == 0)
{
base.ThrowBytesOverflow(encoder, true);
}
bytes++;
bytes[0] = (byte) ch2;
byteCount--;
}
if (byteCount < charCount)
{
base.ThrowBytesOverflow(encoder, byteCount < 1);
charEnd = chars + byteCount;
}
while (chars < charEnd)
{
chars++;
char ch3 = chars[0];
if (ch3 > '\x00ff')
{
bytes++;
bytes[0] = (byte) ch2;
}
else
{
bytes++;
bytes[0] = (byte) ch3;
}
}
if (encoder != null)
{
encoder.charLeftOver = '\0';
encoder.m_charsUsed = (int) ((long) ((chars - chPtr2) / 2));
}
return (int) ((long) ((bytes - numPtr) / 1));
}
}
byte* numPtr2 = bytes + byteCount;
EncoderFallbackBuffer fallbackBuffer = null;
if (charLeftOver > '\0')
{
fallbackBuffer = encoder.FallbackBuffer;
fallbackBuffer.InternalInitialize(chars, charEnd, encoder, true);
fallbackBuffer.InternalFallback(charLeftOver, ref chars);
if (fallbackBuffer.Remaining > ((long) ((numPtr2 - bytes) / 1)))
{
base.ThrowBytesOverflow(encoder, true);
}
}
while (((ch4 = (fallbackBuffer == null) ? '\0' : fallbackBuffer.InternalGetNextChar()) != '\0') || (chars < charEnd))
{
if (ch4 == '\0')
{
ch4 = chars[0];
chars++;
}
if (ch4 > '\x00ff')
{
if (fallbackBuffer == null)
{
if (encoder == null)
{
fallbackBuffer = base.encoderFallback.CreateFallbackBuffer();
}
else
{
fallbackBuffer = encoder.FallbackBuffer;
}
fallbackBuffer.InternalInitialize(charEnd - charCount, charEnd, encoder, true);
}
fallbackBuffer.InternalFallback(ch4, ref chars);
if (fallbackBuffer.Remaining <= ((long) ((numPtr2 - bytes) / 1)))
{
continue;
}
chars--;
fallbackBuffer.InternalReset();
base.ThrowBytesOverflow(encoder, chars == chPtr2);
break;
}
if (bytes >= numPtr2)
{
if ((fallbackBuffer == null) || !fallbackBuffer.bFallingBack)
{
chars--;
}
base.ThrowBytesOverflow(encoder, chars == chPtr2);
break;
}
bytes[0] = (byte) ch4;
bytes++;
}
if (encoder != null)
{
if ((fallbackBuffer != null) && !fallbackBuffer.bUsedEncoder)
{
encoder.charLeftOver = '\0';
}
encoder.m_charsUsed = (int) ((long) ((chars - chPtr2) / 2));
}
return (int) ((long) ((bytes - numPtr) / 1));
}
internal override unsafe int GetBytes(char *chars, int charCount, byte *bytes, int byteCount, EncoderNLS encoder)
{
this.CheckMemorySection();
char ch1 = char.MinValue;
EncoderReplacementFallback replacementFallback;
if (encoder != null)
{
ch1 = encoder.charLeftOver;
replacementFallback = encoder.Fallback as EncoderReplacementFallback;
}
else
{
replacementFallback = this.EncoderFallback as EncoderReplacementFallback;
}
char *charEnd = chars + charCount;
byte *numPtr1 = bytes;
char *chPtr = chars;
if (replacementFallback != null && replacementFallback.MaxCharCount == 1)
{
byte num1 = this.mapUnicodeToBytes[(int)replacementFallback.DefaultString[0]];
if ((int)num1 != 0)
{
if ((int)ch1 > 0)
{
if (byteCount == 0)
{
this.ThrowBytesOverflow(encoder, true);
}
*bytes++ = num1;
--byteCount;
}
if (byteCount < charCount)
{
this.ThrowBytesOverflow(encoder, byteCount < 1);
charEnd = chars + byteCount;
}
while (chars < charEnd)
{
char ch2 = *chars;
chars += 2;
byte num2 = this.mapUnicodeToBytes[(int)ch2];
* bytes = (int)num2 != 0 || (int)ch2 == 0 ? num2 : num1;
++bytes;
}
if (encoder != null)
{
encoder.charLeftOver = char.MinValue;
encoder.m_charsUsed = (int)(chars - chPtr);
}
return((int)(bytes - numPtr1));
}
}
EncoderFallbackBuffer encoderFallbackBuffer = (EncoderFallbackBuffer)null;
byte *numPtr2 = bytes + byteCount;
if ((int)ch1 > 0)
{
encoderFallbackBuffer = encoder.FallbackBuffer;
encoderFallbackBuffer.InternalInitialize(chars, charEnd, encoder, true);
encoderFallbackBuffer.InternalFallback(ch1, ref chars);
if ((long)encoderFallbackBuffer.Remaining > numPtr2 - bytes)
{
this.ThrowBytesOverflow(encoder, true);
}
}
char ch3;
while ((int)(ch3 = encoderFallbackBuffer == null ? char.MinValue : encoderFallbackBuffer.InternalGetNextChar()) != 0 || chars < charEnd)
{
if ((int)ch3 == 0)
{
ch3 = *chars;
chars += 2;
}
byte num = this.mapUnicodeToBytes[(int)ch3];
if ((int)num == 0 && (int)ch3 != 0)
{
if (encoderFallbackBuffer == null)
{
encoderFallbackBuffer = encoder != null ? encoder.FallbackBuffer : this.encoderFallback.CreateFallbackBuffer();
encoderFallbackBuffer.InternalInitialize(charEnd - charCount, charEnd, encoder, true);
}
encoderFallbackBuffer.InternalFallback(ch3, ref chars);
if ((long)encoderFallbackBuffer.Remaining > numPtr2 - bytes)
{
chars -= 2;
encoderFallbackBuffer.InternalReset();
this.ThrowBytesOverflow(encoder, chars == chPtr);
break;
}
}
else
{
if (bytes >= numPtr2)
{
if (encoderFallbackBuffer == null || !encoderFallbackBuffer.bFallingBack)
{
chars -= 2;
}
this.ThrowBytesOverflow(encoder, chars == chPtr);
break;
}
*bytes = num;
++bytes;
}
}
if (encoder != null)
{
if (encoderFallbackBuffer != null && !encoderFallbackBuffer.bUsedEncoder)
{
encoder.charLeftOver = char.MinValue;
}
encoder.m_charsUsed = (int)(chars - chPtr);
}
return((int)(bytes - numPtr1));
}
internal override unsafe int GetBytes(char *chars, int charCount, byte *bytes, int byteCount, EncoderNLS encoder)
{
this.CheckMemorySection();
EncoderFallbackBuffer encoderFallbackBuffer = (EncoderFallbackBuffer)null;
char *charEnd = chars + charCount;
char *chPtr = chars;
byte *numPtr1 = bytes;
byte *numPtr2 = bytes + byteCount;
if (encoder != null)
{
char ch = encoder.charLeftOver;
encoderFallbackBuffer = encoder.FallbackBuffer;
encoderFallbackBuffer.InternalInitialize(chars, charEnd, encoder, true);
if (encoder.m_throwOnOverflow && encoderFallbackBuffer.Remaining > 0)
{
throw new ArgumentException(Environment.GetResourceString("Argument_EncoderFallbackNotEmpty", (object)this.EncodingName, (object)encoder.Fallback.GetType()));
}
if ((int)ch > 0)
{
encoderFallbackBuffer.InternalFallback(ch, ref chars);
}
}
char ch1;
while ((int)(ch1 = encoderFallbackBuffer == null ? char.MinValue : encoderFallbackBuffer.InternalGetNextChar()) != 0 || chars < charEnd)
{
if ((int)ch1 == 0)
{
ch1 = *chars;
chars += 2;
}
ushort num = this.mapUnicodeToBytes[ch1];
if ((int)num == 0 && (int)ch1 != 0)
{
if (encoderFallbackBuffer == null)
{
encoderFallbackBuffer = this.encoderFallback.CreateFallbackBuffer();
encoderFallbackBuffer.InternalInitialize(charEnd - charCount, charEnd, encoder, true);
}
encoderFallbackBuffer.InternalFallback(ch1, ref chars);
}
else
{
if ((int)num >= 256)
{
if (bytes + 1 >= numPtr2)
{
if (encoderFallbackBuffer == null || !encoderFallbackBuffer.bFallingBack)
{
chars -= 2;
}
else
{
encoderFallbackBuffer.MovePrevious();
}
this.ThrowBytesOverflow(encoder, chars == chPtr);
break;
}
*bytes = (byte)((uint)num >> 8);
++bytes;
}
else if (bytes >= numPtr2)
{
if (encoderFallbackBuffer == null || !encoderFallbackBuffer.bFallingBack)
{
chars -= 2;
}
else
{
encoderFallbackBuffer.MovePrevious();
}
this.ThrowBytesOverflow(encoder, chars == chPtr);
break;
}
*bytes = (byte)((uint)num & (uint)byte.MaxValue);
++bytes;
}
}
if (encoder != null)
{
if (encoderFallbackBuffer != null && !encoderFallbackBuffer.bUsedEncoder)
{
encoder.charLeftOver = char.MinValue;
}
encoder.m_charsUsed = (int)(chars - chPtr);
}
return((int)(bytes - numPtr1));
}
internal unsafe override int GetBytes(char *chars, int charCount, byte *bytes, int byteCount, EncoderNLS encoder)
{
char c = '\0';
EncoderFallbackBuffer encoderFallbackBuffer = null;
char *ptr = chars + charCount;
byte *ptr2 = bytes;
char *ptr3 = chars;
EncoderReplacementFallback encoderReplacementFallback;
if (encoder != null)
{
c = encoder.charLeftOver;
encoderReplacementFallback = (encoder.Fallback as EncoderReplacementFallback);
if (encoder.InternalHasFallbackBuffer)
{
encoderFallbackBuffer = encoder.FallbackBuffer;
if (encoderFallbackBuffer.Remaining > 0 && encoder.m_throwOnOverflow)
{
throw new ArgumentException(Environment.GetResourceString("Argument_EncoderFallbackNotEmpty", new object[]
{
this.EncodingName,
encoder.Fallback.GetType()
}));
}
encoderFallbackBuffer.InternalInitialize(ptr3, ptr, encoder, true);
}
}
else
{
encoderReplacementFallback = (base.EncoderFallback as EncoderReplacementFallback);
}
if (encoderReplacementFallback != null && encoderReplacementFallback.MaxCharCount == 1)
{
char c2 = encoderReplacementFallback.DefaultString[0];
if (c2 <= '\u007f')
{
if (c > '\0')
{
if (byteCount == 0)
{
base.ThrowBytesOverflow(encoder, true);
}
*(bytes++) = (byte)c2;
byteCount--;
}
if (byteCount < charCount)
{
base.ThrowBytesOverflow(encoder, byteCount < 1);
ptr = chars + byteCount;
}
while (chars < ptr)
{
char c3 = *(chars++);
if (c3 >= '\u0080')
{
*(bytes++) = (byte)c2;
}
else
{
*(bytes++) = (byte)c3;
}
}
if (encoder != null)
{
encoder.charLeftOver = '\0';
encoder.m_charsUsed = (int)((long)(chars - ptr3));
}
return((int)((long)(bytes - ptr2)));
}
}
byte *ptr4 = bytes + byteCount;
if (c > '\0')
{
encoderFallbackBuffer = encoder.FallbackBuffer;
encoderFallbackBuffer.InternalInitialize(chars, ptr, encoder, true);
encoderFallbackBuffer.InternalFallback(c, ref chars);
}
char c4;
while ((c4 = ((encoderFallbackBuffer == null) ? '\0' : encoderFallbackBuffer.InternalGetNextChar())) != '\0' || chars < ptr)
{
if (c4 == '\0')
{
c4 = *chars;
chars++;
}
if (c4 > '\u007f')
{
if (encoderFallbackBuffer == null)
{
if (encoder == null)
{
encoderFallbackBuffer = this.encoderFallback.CreateFallbackBuffer();
}
else
{
encoderFallbackBuffer = encoder.FallbackBuffer;
}
encoderFallbackBuffer.InternalInitialize(ptr - charCount, ptr, encoder, true);
}
encoderFallbackBuffer.InternalFallback(c4, ref chars);
}
else
{
if (bytes >= ptr4)
{
if (encoderFallbackBuffer == null || !encoderFallbackBuffer.bFallingBack)
{
chars--;
}
else
{
encoderFallbackBuffer.MovePrevious();
}
base.ThrowBytesOverflow(encoder, bytes == ptr2);
break;
}
*bytes = (byte)c4;
bytes++;
}
}
if (encoder != null)
{
if (encoderFallbackBuffer != null && !encoderFallbackBuffer.bUsedEncoder)
{
encoder.charLeftOver = '\0';
}
encoder.m_charsUsed = (int)((long)(chars - ptr3));
}
return((int)((long)(bytes - ptr2)));
}
internal unsafe override int GetByteCount(char *chars, int charCount, EncoderNLS encoder)
{
char c = '\0';
EncoderReplacementFallback encoderReplacementFallback;
if (encoder != null)
{
c = encoder.charLeftOver;
encoderReplacementFallback = (encoder.Fallback as EncoderReplacementFallback);
}
else
{
encoderReplacementFallback = (base.EncoderFallback as EncoderReplacementFallback);
}
if (encoderReplacementFallback != null && encoderReplacementFallback.MaxCharCount == 1)
{
if (c > '\0')
{
charCount++;
}
return(charCount);
}
int num = 0;
char *ptr = chars + charCount;
EncoderFallbackBuffer encoderFallbackBuffer = null;
if (c > '\0')
{
encoderFallbackBuffer = encoder.FallbackBuffer;
encoderFallbackBuffer.InternalInitialize(chars, ptr, encoder, false);
encoderFallbackBuffer.InternalFallback(c, ref chars);
}
char c2;
while ((c2 = ((encoderFallbackBuffer == null) ? '\0' : encoderFallbackBuffer.InternalGetNextChar())) != '\0' || chars < ptr)
{
if (c2 == '\0')
{
c2 = *chars;
chars++;
}
if (c2 > 'ÿ')
{
if (encoderFallbackBuffer == null)
{
if (encoder == null)
{
encoderFallbackBuffer = this.encoderFallback.CreateFallbackBuffer();
}
else
{
encoderFallbackBuffer = encoder.FallbackBuffer;
}
encoderFallbackBuffer.InternalInitialize(ptr - charCount, ptr, encoder, false);
}
encoderFallbackBuffer.InternalFallback(c2, ref chars);
}
else
{
num++;
}
}
return(num);
}
[System.Security.SecurityCritical] // auto-generated
internal override unsafe int GetByteCount(char *chars, int count, EncoderNLS encoder)
{
// Just need to ASSERT, this is called by something else internal that checked parameters already
Contract.Assert(count >= 0, "[SBCSCodePageEncoding.GetByteCount]count is negative");
Contract.Assert(chars != null, "[SBCSCodePageEncoding.GetByteCount]chars is null");
// Assert because we shouldn't be able to have a null encoder.
Contract.Assert(encoderFallback != null, "[SBCSCodePageEncoding.GetByteCount]Attempting to use null fallback");
CheckMemorySection();
// Need to test fallback
EncoderReplacementFallback fallback = null;
// Get any left over characters
char charLeftOver = (char)0;
if (encoder != null)
{
charLeftOver = encoder.charLeftOver;
Contract.Assert(charLeftOver == 0 || Char.IsHighSurrogate(charLeftOver),
"[SBCSCodePageEncoding.GetByteCount]leftover character should be high surrogate");
fallback = encoder.Fallback as EncoderReplacementFallback;
// Verify that we have no fallbackbuffer, actually for SBCS this is always empty, so just assert
Contract.Assert(!encoder.m_throwOnOverflow || !encoder.InternalHasFallbackBuffer ||
encoder.FallbackBuffer.Remaining == 0,
"[SBCSCodePageEncoding.GetByteCount]Expected empty fallback buffer at start");
}
else
{
// If we aren't using default fallback then we may have a complicated count.
fallback = this.EncoderFallback as EncoderReplacementFallback;
}
if ((fallback != null && fallback.MaxCharCount == 1) /* || bIsBestFit*/)
{
// Replacement fallback encodes surrogate pairs as two ?? (or two whatever), so return size is always
// same as input size.
// Note that no existing SBCS code pages map code points to supplimentary characters, so this is easy.
// We could however have 1 extra byte if the last call had an encoder and a funky fallback and
// if we don't use the funky fallback this time.
// Do we have an extra char left over from last time?
if (charLeftOver > 0)
{
count++;
}
return(count);
}
// It had a funky fallback, so its more complicated
// Need buffer maybe later
EncoderFallbackBuffer fallbackBuffer = null;
// prepare our end
int byteCount = 0;
char *charEnd = chars + count;
// We may have a left over character from last time, try and process it.
if (charLeftOver > 0)
{
// Since left over char was a surrogate, it'll have to be fallen back.
// Get Fallback
Contract.Assert(encoder != null, "[SBCSCodePageEncoding.GetByteCount]Expect to have encoder if we have a charLeftOver");
fallbackBuffer = encoder.FallbackBuffer;
fallbackBuffer.InternalInitialize(chars, charEnd, encoder, false);
// This will fallback a pair if *chars is a low surrogate
fallbackBuffer.InternalFallback(charLeftOver, ref chars);
}
// Now we may have fallback char[] already from the encoder
// Go ahead and do it, including the fallback.
char ch;
while ((ch = (fallbackBuffer == null) ? '\0' : fallbackBuffer.InternalGetNextChar()) != 0 ||
chars < charEnd)
{
// First unwind any fallback
if (ch == 0)
{
// No fallback, just get next char
ch = *chars;
chars++;
}
// get byte for this char
byte bTemp = mapUnicodeToBytes[ch];
// Check for fallback, this'll catch surrogate pairs too.
if (bTemp == 0 && ch != (char)0)
{
if (fallbackBuffer == null)
{
// Create & init fallback buffer
if (encoder == null)
{
fallbackBuffer = this.encoderFallback.CreateFallbackBuffer();
}
else
{
fallbackBuffer = encoder.FallbackBuffer;
}
// chars has moved so we need to remember figure it out so Exception fallback
// index will be correct
fallbackBuffer.InternalInitialize(charEnd - count, charEnd, encoder, false);
}
// Get Fallback
fallbackBuffer.InternalFallback(ch, ref chars);
continue;
}
// We'll use this one
byteCount++;
}
Contract.Assert(fallbackBuffer == null || fallbackBuffer.Remaining == 0,
"[SBCSEncoding.GetByteCount]Expected Empty fallback buffer at end");
return((int)byteCount);
}
internal override unsafe int GetByteCount(char *chars, int charCount, EncoderNLS encoder)
{
char ch1 = char.MinValue;
char *charEnd = chars + charCount;
EncoderFallbackBuffer encoderFallbackBuffer = (EncoderFallbackBuffer)null;
EncoderReplacementFallback replacementFallback;
if (encoder != null)
{
ch1 = encoder.charLeftOver;
replacementFallback = encoder.Fallback as EncoderReplacementFallback;
if (encoder.InternalHasFallbackBuffer)
{
encoderFallbackBuffer = encoder.FallbackBuffer;
if (encoderFallbackBuffer.Remaining > 0 && encoder.m_throwOnOverflow)
{
throw new ArgumentException(Environment.GetResourceString("Argument_EncoderFallbackNotEmpty", (object)this.EncodingName, (object)encoder.Fallback.GetType()));
}
encoderFallbackBuffer.InternalInitialize(chars, charEnd, encoder, false);
}
}
else
{
replacementFallback = this.EncoderFallback as EncoderReplacementFallback;
}
if (replacementFallback != null && replacementFallback.MaxCharCount == 1)
{
if ((int)ch1 > 0)
{
++charCount;
}
return(charCount);
}
int num = 0;
if ((int)ch1 > 0)
{
encoderFallbackBuffer = encoder.FallbackBuffer;
encoderFallbackBuffer.InternalInitialize(chars, charEnd, encoder, false);
encoderFallbackBuffer.InternalFallback(ch1, ref chars);
}
char ch2;
while ((int)(ch2 = encoderFallbackBuffer == null ? char.MinValue : encoderFallbackBuffer.InternalGetNextChar()) != 0 || chars < charEnd)
{
if ((int)ch2 == 0)
{
ch2 = *chars;
chars += 2;
}
if ((int)ch2 > (int)sbyte.MaxValue)
{
if (encoderFallbackBuffer == null)
{
encoderFallbackBuffer = encoder != null ? encoder.FallbackBuffer : this.encoderFallback.CreateFallbackBuffer();
encoderFallbackBuffer.InternalInitialize(charEnd - charCount, charEnd, encoder, false);
}
encoderFallbackBuffer.InternalFallback(ch2, ref chars);
}
else
{
++num;
}
}
return(num);
}