public void Defaults ()
{
DecoderReplacementFallback f =
new DecoderReplacementFallback ();
Assert.AreEqual ("?", f.DefaultString, "#1");
Assert.AreEqual (1, f.MaxCharCount, "#2");
f = new DecoderReplacementFallback (String.Empty);
Assert.AreEqual (String.Empty, f.DefaultString, "#3");
Assert.AreEqual (0, f.MaxCharCount, "#4");
f = Encoding.UTF8.DecoderFallback as DecoderReplacementFallback;
Assert.IsNotNull (f, "#5");
// This behavior was introduced as
// http://support.microsoft.com/kb/940521/
Assert.AreEqual ("\uFFFD", f.DefaultString, "#6");
Assert.AreEqual (1, f.MaxCharCount, "#7");
// after beta2 this test became invalid.
//f = new MyEncoding ().DecoderFallback as DecoderReplacementFallback;
//Assert.IsNotNull (f, "#8");
//Assert.AreEqual (String.Empty, f.DefaultString, "#9");
//Assert.AreEqual (0, f.MaxCharCount, "#10");
f = DecoderFallback.ReplacementFallback as DecoderReplacementFallback;
Assert.AreEqual ("?", f.DefaultString, "#11");
Assert.AreEqual (1, f.MaxCharCount, "#12");
}
// This is internal and called by something else,
internal override unsafe int GetCharCount(byte *bytes, int count, DecoderNLS decoder)
{
// ASCII doesn't do best fit, so don't have to check for it, find out which decoder fallback we're using
DecoderReplacementFallback fallback = null;
if (decoder == null)
{
fallback = this.DecoderFallback as DecoderReplacementFallback;
}
else
{
fallback = decoder.Fallback as DecoderReplacementFallback;
}
if (fallback != null && fallback.MaxCharCount == 1)
{
// Just return length, SBCS stay the same length because they don't map to surrogate
// pairs and we don't have a decoder fallback.
return(count);
}
// Only need decoder fallback buffer if not using default replacement fallback, no best fit for ASCII
DecoderFallbackBuffer fallbackBuffer = null;
// Have to do it the hard way.
// Assume charCount will be == count
int charCount = count;
byte[] byteBuffer = new byte[1];
// Do it our fast way
byte *byteEnd = bytes + count;
// Quick loop
while (bytes < byteEnd)
{
// Faster if don't use *bytes++;
byte b = *bytes;
bytes++;
// If unknown we have to do fallback count
if (b >= 0x80)
{
if (fallbackBuffer == null)
{
if (decoder == null)
{
fallbackBuffer = this.DecoderFallback.CreateFallbackBuffer();
}
else
{
fallbackBuffer = decoder.FallbackBuffer;
}
fallbackBuffer.InternalInitialize(byteEnd - count, null);
}
// Use fallback buffer
byteBuffer[0] = b;
charCount--; // Have to unreserve the one we already allocated for b
charCount += fallbackBuffer.InternalFallback(byteBuffer, bytes);
}
}
// Converted sequence is same length as input
return(charCount);
}
internal override unsafe int GetChars(byte *bytes, int byteCount, char *chars, int charCount, DecoderNLS decoder)
{
byte *numPtr = bytes + byteCount;
byte *numPtr2 = bytes;
char *chPtr = chars;
DecoderReplacementFallback decoderFallback = null;
if (decoder == null)
{
decoderFallback = base.DecoderFallback as DecoderReplacementFallback;
}
else
{
decoderFallback = decoder.Fallback as DecoderReplacementFallback;
}
if ((decoderFallback != null) && (decoderFallback.MaxCharCount == 1))
{
char ch = decoderFallback.DefaultString[0];
if (charCount < byteCount)
{
base.ThrowCharsOverflow(decoder, charCount < 1);
numPtr = bytes + charCount;
}
while (bytes < numPtr)
{
bytes++;
byte num = bytes[0];
if (num >= 0x80)
{
chars++;
chars[0] = ch;
}
else
{
chars++;
chars[0] = (char)num;
}
}
if (decoder != null)
{
decoder.m_bytesUsed = (int)((long)((bytes - numPtr2) / 1));
}
return((int)((long)((chars - chPtr) / 2)));
}
DecoderFallbackBuffer fallbackBuffer = null;
byte[] buffer2 = new byte[1];
char * charEnd = chars + charCount;
while (bytes < numPtr)
{
byte num2 = bytes[0];
bytes++;
if (num2 >= 0x80)
{
if (fallbackBuffer == null)
{
if (decoder == null)
{
fallbackBuffer = base.DecoderFallback.CreateFallbackBuffer();
}
else
{
fallbackBuffer = decoder.FallbackBuffer;
}
fallbackBuffer.InternalInitialize(numPtr - byteCount, charEnd);
}
buffer2[0] = num2;
if (fallbackBuffer.InternalFallback(buffer2, bytes, ref chars))
{
continue;
}
bytes--;
fallbackBuffer.InternalReset();
base.ThrowCharsOverflow(decoder, chars == chPtr);
break;
}
if (chars >= charEnd)
{
bytes--;
base.ThrowCharsOverflow(decoder, chars == chPtr);
break;
}
chars[0] = (char)num2;
chars++;
}
if (decoder != null)
{
decoder.m_bytesUsed = (int)((long)((bytes - numPtr2) / 1));
}
return((int)((long)((chars - chPtr) / 2)));
}
// Construction
public DecoderReplacementFallbackBuffer(DecoderReplacementFallback fallback)
{
this.strDefault = fallback.DefaultString;
}
public override DecoderFallbackBuffer CreateFallbackBuffer ()
{
fallback = new DecoderReplacementFallback ();
return new DecoderTestFallbackBuffer (fallback, fallbackAction);
}
[System.Security.SecurityCritical] // auto-generated
internal override unsafe int GetCharCount(byte *bytes, int count, DecoderNLS decoder)
{
// Just assert, we're called internally so these should be safe, checked already
Contract.Assert(bytes != null, "[ASCIIEncoding.GetCharCount]bytes is null");
Contract.Assert(count >= 0, "[ASCIIEncoding.GetCharCount]byteCount is negative");
// ASCII doesn't do best fit, so don't have to check for it, find out which decoder fallback we're using
DecoderReplacementFallback fallback = null;
if (decoder == null)
{
fallback = this.DecoderFallback as DecoderReplacementFallback;
}
else
{
fallback = decoder.Fallback as DecoderReplacementFallback;
Contract.Assert(!decoder.m_throwOnOverflow || !decoder.InternalHasFallbackBuffer ||
decoder.FallbackBuffer.Remaining == 0,
"[ASCIICodePageEncoding.GetCharCount]Expected empty fallback buffer");
}
if (fallback != null && fallback.MaxCharCount == 1)
{
// Just return length, SBCS stay the same length because they don't map to surrogate
// pairs and we don't have a decoder fallback.
return(count);
}
// Only need decoder fallback buffer if not using default replacement fallback, no best fit for ASCII
DecoderFallbackBuffer fallbackBuffer = null;
// Have to do it the hard way.
// Assume charCount will be == count
int charCount = count;
byte[] byteBuffer = new byte[1];
// Do it our fast way
byte *byteEnd = bytes + count;
// Quick loop
while (bytes < byteEnd)
{
// Faster if don't use *bytes++;
byte b = *bytes;
bytes++;
// If unknown we have to do fallback count
if (b >= 0x80)
{
if (fallbackBuffer == null)
{
if (decoder == null)
{
fallbackBuffer = this.DecoderFallback.CreateFallbackBuffer();
}
else
{
fallbackBuffer = decoder.FallbackBuffer;
}
fallbackBuffer.InternalInitialize(byteEnd - count, null);
}
// Use fallback buffer
byteBuffer[0] = b;
charCount--; // Have to unreserve the one we already allocated for b
charCount += fallbackBuffer.InternalFallback(byteBuffer, bytes);
}
}
// Fallback buffer must be empty
Contract.Assert(fallbackBuffer == null || fallbackBuffer.Remaining == 0,
"[ASCIIEncoding.GetCharCount]Expected Empty fallback buffer");
// Converted sequence is same length as input
return(charCount);
}
/// <summary>Indicates whether the value of a specified object is equal to the <see cref="T:System.Text.DecoderReplacementFallback" /> object.</summary>
/// <returns>true if <paramref name="value" /> is a <see cref="T:System.Text.DecoderReplacementFallback" /> object having a <see cref="P:System.Text.DecoderReplacementFallback.DefaultString" /> property that is equal to the <see cref="P:System.Text.DecoderReplacementFallback.DefaultString" /> property of the current <see cref="T:System.Text.DecoderReplacementFallback" /> object; otherwise, false. </returns>
/// <param name="value">A <see cref="T:System.Text.DecoderReplacementFallback" /> object.</param>
/// <filterpriority>2</filterpriority>
public override bool Equals(object value)
{
DecoderReplacementFallback decoderReplacementFallback = value as DecoderReplacementFallback;
return(decoderReplacementFallback != null && this.replacement == decoderReplacementFallback.replacement);
}
// Construction
public DecoderReplacementFallbackBuffer(DecoderReplacementFallback fallback)
{
// TODO-NULLABLE: NullReferenceException (fallback)
_strDefault = fallback.DefaultString;
}
public override bool Equals(object value)
{
DecoderReplacementFallback f = value as DecoderReplacementFallback;
return(f != null && replacement == f.replacement);
}
public static Encoding GetEncoding(string charset, string fallback)
{
int codepage;
if (charset == null)
throw new ArgumentNullException ("charset");
if (fallback == null)
throw new ArgumentNullException ("fallback");
if ((codepage = GetCodePage (charset)) == -1)
throw new NotSupportedException ();
var encoderFallback = new EncoderReplacementFallback (fallback);
var decoderFallback = new DecoderReplacementFallback (fallback);
return Encoding.GetEncoding (codepage, encoderFallback, decoderFallback);
}
public static Encoding GetEncoding(int codepage, string fallback)
{
if (fallback == null)
throw new ArgumentNullException ("fallback");
var encoderFallback = new EncoderReplacementFallback (fallback);
var decoderFallback = new DecoderReplacementFallback (fallback);
return Encoding.GetEncoding (codepage, encoderFallback, decoderFallback);
}
public DecoderReplacementFallbackBuffer(
DecoderReplacementFallback fallback)
{
if (fallback == null)
throw new ArgumentNullException("fallback");
replacement = fallback.DefaultString;
current = 0;
}
internal override unsafe int GetChars(byte *bytes, int byteCount, char *chars, int charCount, DecoderNLS decoder)
{
byte *numPtr1 = bytes + byteCount;
byte *numPtr2 = bytes;
char *chPtr = chars;
DecoderReplacementFallback replacementFallback = decoder != null ? decoder.Fallback as DecoderReplacementFallback : this.DecoderFallback as DecoderReplacementFallback;
if (replacementFallback != null && replacementFallback.MaxCharCount == 1)
{
char ch = replacementFallback.DefaultString[0];
if (charCount < byteCount)
{
this.ThrowCharsOverflow(decoder, charCount < 1);
numPtr1 = bytes + charCount;
}
while (bytes < numPtr1)
{
byte num = *bytes++;
* chars++ = (int)num < 128 ? (char)num : ch;
}
if (decoder != null)
{
decoder.m_bytesUsed = (int)(bytes - numPtr2);
}
return((int)(chars - chPtr));
}
DecoderFallbackBuffer decoderFallbackBuffer = (DecoderFallbackBuffer)null;
byte[] bytes1 = new byte[1];
char * charEnd = chars + charCount;
while (bytes < numPtr1)
{
byte num = *bytes;
++bytes;
if ((int)num >= 128)
{
if (decoderFallbackBuffer == null)
{
decoderFallbackBuffer = decoder != null ? decoder.FallbackBuffer : this.DecoderFallback.CreateFallbackBuffer();
decoderFallbackBuffer.InternalInitialize(numPtr1 - byteCount, charEnd);
}
bytes1[0] = num;
if (!decoderFallbackBuffer.InternalFallback(bytes1, bytes, ref chars))
{
--bytes;
decoderFallbackBuffer.InternalReset();
this.ThrowCharsOverflow(decoder, chars == chPtr);
break;
}
}
else
{
if (chars >= charEnd)
{
--bytes;
this.ThrowCharsOverflow(decoder, chars == chPtr);
break;
}
*chars = (char)num;
chars += 2;
}
}
if (decoder != null)
{
decoder.m_bytesUsed = (int)(bytes - numPtr2);
}
return((int)(chars - chPtr));
}
public DecoderReplacementFallbackBuffer(DecoderReplacementFallback fallback)
{
Contract.Requires(fallback != null);
}
// Construction
public DecoderReplacementFallbackBuffer(DecoderReplacementFallback fallback)
{
_strDefault = fallback.DefaultString;
}
/// <summary>Initializes a new instance of the <see cref="T:System.Text.DecoderReplacementFallbackBuffer" /> class using the value of a <see cref="T:System.Text.DecoderReplacementFallback" /> object.</summary><param name="fallback">A <see cref="T:System.Text.DecoderReplacementFallback" /> object that contains a replacement string. </param>
public DecoderReplacementFallbackBuffer(DecoderReplacementFallback fallback)
{
throw new NotImplementedException();
}
[System.Security.SecurityCritical] // auto-generated
public override unsafe int GetChars(byte *bytes, int byteCount,
char *chars, int charCount, DecoderNLS decoder)
{
// Just need to ASSERT, this is called by something else internal that checked parameters already
Debug.Assert(bytes != null, "[SBCSCodePageEncoding.GetChars]bytes is null");
Debug.Assert(byteCount >= 0, "[SBCSCodePageEncoding.GetChars]byteCount is negative");
Debug.Assert(chars != null, "[SBCSCodePageEncoding.GetChars]chars is null");
Debug.Assert(charCount >= 0, "[SBCSCodePageEncoding.GetChars]charCount is negative");
CheckMemorySection();
// See if we have best fit
bool bUseBestFit = false;
// Do it fast way if using ? replacement or best fit fallbacks
byte *byteEnd = bytes + byteCount;
byte *byteStart = bytes;
char *charStart = chars;
// Only need decoder fallback buffer if not using default replacement fallback or best fit fallback.
DecoderReplacementFallback fallback = null;
if (decoder == null)
{
fallback = DecoderFallback as DecoderReplacementFallback;
bUseBestFit = DecoderFallback is InternalDecoderBestFitFallback;
}
else
{
fallback = decoder.Fallback as DecoderReplacementFallback;
bUseBestFit = decoder.Fallback is InternalDecoderBestFitFallback;
Debug.Assert(!decoder.m_throwOnOverflow || !decoder.InternalHasFallbackBuffer ||
decoder.FallbackBuffer.Remaining == 0,
"[SBCSCodePageEncoding.GetChars]Expected empty fallback buffer at start");
}
if (bUseBestFit || (fallback != null && fallback.MaxCharCount == 1))
{
// Try it the fast way
char replacementChar;
if (fallback == null)
{
replacementChar = '?'; // Best fit always has ? for fallback for SBCS
}
else
{
replacementChar = fallback.DefaultString[0];
}
// Need byteCount chars, otherwise too small buffer
if (charCount < byteCount)
{
// Need at least 1 output byte, throw if must throw
ThrowCharsOverflow(decoder, charCount < 1);
// Not throwing, use what we can
byteEnd = bytes + charCount;
}
// Quick loop, just do '?' replacement because we don't have fallbacks for decodings.
while (bytes < byteEnd)
{
char c;
if (bUseBestFit)
{
if (arrayBytesBestFit == null)
{
ReadBestFitTable();
}
c = arrayBytesBestFit[*bytes];
}
else
{
c = _mapBytesToUnicode[*bytes];
}
bytes++;
if (c == UNKNOWN_CHAR)
{
// This is an invalid byte in the ASCII encoding.
*chars = replacementChar;
}
else
{
*chars = c;
}
chars++;
}
// bytes & chars used are the same
if (decoder != null)
{
decoder.m_bytesUsed = (int)(bytes - byteStart);
}
return((int)(chars - charStart));
}
// Slower way's going to need a fallback buffer
DecoderFallbackBuffer fallbackBuffer = null;
byte[] byteBuffer = new byte[1];
char * charEnd = chars + charCount;
DecoderFallbackBufferHelper fallbackHelper = new DecoderFallbackBufferHelper(
decoder != null ? decoder.FallbackBuffer : DecoderFallback.CreateFallbackBuffer());
// Not quite so fast loop
while (bytes < byteEnd)
{
// Faster if don't use *bytes++;
char c = _mapBytesToUnicode[*bytes];
bytes++;
// See if it was unknown
if (c == UNKNOWN_CHAR)
{
// Make sure we have a fallback buffer
if (fallbackBuffer == null)
{
if (decoder == null)
{
fallbackBuffer = DecoderFallback.CreateFallbackBuffer();
}
else
{
fallbackBuffer = decoder.FallbackBuffer;
}
fallbackHelper = new DecoderFallbackBufferHelper(fallbackBuffer);
fallbackHelper.InternalInitialize(byteEnd - byteCount, charEnd);
}
// Use fallback buffer
Debug.Assert(bytes > byteStart,
"[SBCSCodePageEncoding.GetChars]Expected bytes to have advanced already (unknown byte)");
byteBuffer[0] = *(bytes - 1);
// Fallback adds fallback to chars, but doesn't increment chars unless the whole thing fits.
if (!fallbackHelper.InternalFallback(byteBuffer, bytes, ref chars))
{
// May or may not throw, but we didn't get this byte
bytes--; // unused byte
fallbackHelper.InternalReset(); // Didn't fall this back
ThrowCharsOverflow(decoder, bytes == byteStart); // throw?
break; // don't throw, but stop loop
}
}
else
{
// Make sure we have buffer space
if (chars >= charEnd)
{
Debug.Assert(bytes > byteStart,
"[SBCSCodePageEncoding.GetChars]Expected bytes to have advanced already (known byte)");
bytes--; // unused byte
ThrowCharsOverflow(decoder, bytes == byteStart); // throw?
break; // don't throw, but stop loop
}
*(chars) = c;
chars++;
}
}
// Might have had decoder fallback stuff.
if (decoder != null)
{
decoder.m_bytesUsed = (int)(bytes - byteStart);
}
// Expect Empty fallback buffer for GetChars
Debug.Assert(fallbackBuffer == null || fallbackBuffer.Remaining == 0,
"[SBCSEncoding.GetChars]Expected Empty fallback buffer at end");
return((int)(chars - charStart));
}
public override bool Equals(object value)
{
DecoderReplacementFallback fallback = value as DecoderReplacementFallback;
return((fallback != null) && (this.strDefault == fallback.strDefault));
}
[System.Security.SecurityCritical] // auto-generated
internal override unsafe int GetChars(byte *bytes, int byteCount,
char *chars, int charCount, DecoderNLS decoder)
{
// Just need to ASSERT, this is called by something else internal that checked parameters already
Contract.Assert(bytes != null, "[ASCIIEncoding.GetChars]bytes is null");
Contract.Assert(byteCount >= 0, "[ASCIIEncoding.GetChars]byteCount is negative");
Contract.Assert(chars != null, "[ASCIIEncoding.GetChars]chars is null");
Contract.Assert(charCount >= 0, "[ASCIIEncoding.GetChars]charCount is negative");
// Do it fast way if using ? replacement fallback
byte *byteEnd = bytes + byteCount;
byte *byteStart = bytes;
char *charStart = chars;
// Note: ASCII doesn't do best fit, but we have to fallback if they use something > 0x7f
// Only need decoder fallback buffer if not using ? fallback.
// ASCII doesn't do best fit, so don't have to check for it, find out which decoder fallback we're using
DecoderReplacementFallback fallback = null;
if (decoder == null)
{
fallback = this.DecoderFallback as DecoderReplacementFallback;
}
else
{
fallback = decoder.Fallback as DecoderReplacementFallback;
Contract.Assert(!decoder.m_throwOnOverflow || !decoder.InternalHasFallbackBuffer ||
decoder.FallbackBuffer.Remaining == 0,
"[ASCIICodePageEncoding.GetChars]Expected empty fallback buffer");
}
if (fallback != null && fallback.MaxCharCount == 1)
{
// Try it the fast way
char replacementChar = fallback.DefaultString[0];
// Need byteCount chars, otherwise too small buffer
if (charCount < byteCount)
{
// Need at least 1 output byte, throw if must throw
ThrowCharsOverflow(decoder, charCount < 1);
// Not throwing, use what we can
byteEnd = bytes + charCount;
}
// Quick loop, just do '?' replacement because we don't have fallbacks for decodings.
while (bytes < byteEnd)
{
byte b = *(bytes++);
if (b >= 0x80)
{
// This is an invalid byte in the ASCII encoding.
*(chars++) = replacementChar;
}
else
{
*(chars++) = unchecked ((char)b);
}
}
// bytes & chars used are the same
if (decoder != null)
{
decoder.m_bytesUsed = (int)(bytes - byteStart);
}
return((int)(chars - charStart));
}
// Slower way's going to need a fallback buffer
DecoderFallbackBuffer fallbackBuffer = null;
byte[] byteBuffer = new byte[1];
char * charEnd = chars + charCount;
// Not quite so fast loop
while (bytes < byteEnd)
{
// Faster if don't use *bytes++;
byte b = *(bytes);
bytes++;
if (b >= 0x80)
{
// This is an invalid byte in the ASCII encoding.
if (fallbackBuffer == null)
{
if (decoder == null)
{
fallbackBuffer = this.DecoderFallback.CreateFallbackBuffer();
}
else
{
fallbackBuffer = decoder.FallbackBuffer;
}
fallbackBuffer.InternalInitialize(byteEnd - byteCount, charEnd);
}
// Use fallback buffer
byteBuffer[0] = b;
// Note that chars won't get updated unless this succeeds
if (!fallbackBuffer.InternalFallback(byteBuffer, bytes, ref chars))
{
// May or may not throw, but we didn't get this byte
Contract.Assert(bytes > byteStart || chars == charStart,
"[ASCIIEncoding.GetChars]Expected bytes to have advanced already (fallback case)");
bytes--; // unused byte
fallbackBuffer.InternalReset(); // Didn't fall this back
ThrowCharsOverflow(decoder, chars == charStart); // throw?
break; // don't throw, but stop loop
}
}
else
{
// Make sure we have buffer space
if (chars >= charEnd)
{
Contract.Assert(bytes > byteStart || chars == charStart,
"[ASCIIEncoding.GetChars]Expected bytes to have advanced already (normal case)");
bytes--; // unused byte
ThrowCharsOverflow(decoder, chars == charStart); // throw?
break; // don't throw, but stop loop
}
*(chars) = unchecked ((char)b);
chars++;
}
}
// Might have had decoder fallback stuff.
if (decoder != null)
{
decoder.m_bytesUsed = (int)(bytes - byteStart);
}
// Expect Empty fallback buffer for GetChars
Contract.Assert(fallbackBuffer == null || fallbackBuffer.Remaining == 0,
"[ASCIIEncoding.GetChars]Expected Empty fallback buffer");
return((int)(chars - charStart));
}
public DecoderReplacementFallbackBuffer(DecoderReplacementFallback fallback)
{
Contract.Requires(fallback != null);
}
[System.Security.SecurityCritical] // auto-generated
internal override unsafe int GetCharCount(byte *bytes, int count, DecoderNLS decoder)
{
// Just assert, we're called internally so these should be safe, checked already
Contract.Assert(bytes != null, "[SBCSCodePageEncoding.GetCharCount]bytes is null");
Contract.Assert(count >= 0, "[SBCSCodePageEncoding.GetCharCount]byteCount is negative");
CheckMemorySection();
// See if we have best fit
bool bUseBestFit = false;
// Only need decoder fallback buffer if not using default replacement fallback or best fit fallback.
DecoderReplacementFallback fallback = null;
if (decoder == null)
{
fallback = this.DecoderFallback as DecoderReplacementFallback;
bUseBestFit = this.DecoderFallback.IsMicrosoftBestFitFallback;
}
else
{
fallback = decoder.Fallback as DecoderReplacementFallback;
bUseBestFit = decoder.Fallback.IsMicrosoftBestFitFallback;
Contract.Assert(!decoder.m_throwOnOverflow || !decoder.InternalHasFallbackBuffer ||
decoder.FallbackBuffer.Remaining == 0,
"[SBCSCodePageEncoding.GetChars]Expected empty fallback buffer at start");
}
if (bUseBestFit || (fallback != null && fallback.MaxCharCount == 1))
{
// Just return length, SBCS stay the same length because they don't map to surrogate
// pairs and we don't have a decoder fallback.
return(count);
}
// Might need one of these later
DecoderFallbackBuffer fallbackBuffer = null;
// Have to do it the hard way.
// Assume charCount will be == count
int charCount = count;
byte[] byteBuffer = new byte[1];
// Do it our fast way
byte *byteEnd = bytes + count;
// Quick loop
while (bytes < byteEnd)
{
// Faster if don't use *bytes++;
char c;
c = mapBytesToUnicode[*bytes];
bytes++;
// If unknown we have to do fallback count
if (c == UNKNOWN_CHAR)
{
// Must have a fallback buffer
if (fallbackBuffer == null)
{
// Need to adjust count so we get real start
if (decoder == null)
{
fallbackBuffer = this.DecoderFallback.CreateFallbackBuffer();
}
else
{
fallbackBuffer = decoder.FallbackBuffer;
}
fallbackBuffer.InternalInitialize(byteEnd - count, null);
}
// Use fallback buffer
byteBuffer[0] = *(bytes - 1);
charCount--; // We'd already reserved one for *(bytes-1)
charCount += fallbackBuffer.InternalFallback(byteBuffer, bytes);
}
}
// Fallback buffer must be empty
Contract.Assert(fallbackBuffer == null || fallbackBuffer.Remaining == 0,
"[SBCSEncoding.GetCharCount]Expected Empty fallback buffer at end");
// Converted sequence is same length as input
return(charCount);
}
internal override unsafe int GetChars(byte *bytes, int byteCount, char *chars, int charCount, DecoderNLS decoder)
{
base.CheckMemorySection();
bool isMicrosoftBestFitFallback = false;
byte *numPtr = bytes + byteCount;
byte *numPtr2 = bytes;
char *chPtr = chars;
DecoderReplacementFallback decoderFallback = null;
if (decoder == null)
{
decoderFallback = base.DecoderFallback as DecoderReplacementFallback;
isMicrosoftBestFitFallback = base.DecoderFallback.IsMicrosoftBestFitFallback;
}
else
{
decoderFallback = decoder.Fallback as DecoderReplacementFallback;
isMicrosoftBestFitFallback = decoder.Fallback.IsMicrosoftBestFitFallback;
}
if (isMicrosoftBestFitFallback || ((decoderFallback != null) && (decoderFallback.MaxCharCount == 1)))
{
char ch;
if (decoderFallback == null)
{
ch = '?';
}
else
{
ch = decoderFallback.DefaultString[0];
}
if (charCount < byteCount)
{
base.ThrowCharsOverflow(decoder, charCount < 1);
numPtr = bytes + charCount;
}
while (bytes < numPtr)
{
char ch2;
if (isMicrosoftBestFitFallback)
{
if (base.arrayBytesBestFit == null)
{
this.ReadBestFitTable();
}
ch2 = base.arrayBytesBestFit[bytes[0]];
}
else
{
ch2 = this.mapBytesToUnicode[bytes[0]];
}
bytes++;
if (ch2 == 0xfffd)
{
chars[0] = ch;
}
else
{
chars[0] = ch2;
}
chars++;
}
if (decoder != null)
{
decoder.m_bytesUsed = (int)((long)((bytes - numPtr2) / 1));
}
return((int)((long)((chars - chPtr) / 2)));
}
DecoderFallbackBuffer fallbackBuffer = null;
byte[] buffer2 = new byte[1];
char * charEnd = chars + charCount;
while (bytes < numPtr)
{
char ch3 = this.mapBytesToUnicode[bytes[0]];
bytes++;
if (ch3 == 0xfffd)
{
if (fallbackBuffer == null)
{
if (decoder == null)
{
fallbackBuffer = base.DecoderFallback.CreateFallbackBuffer();
}
else
{
fallbackBuffer = decoder.FallbackBuffer;
}
fallbackBuffer.InternalInitialize(numPtr - byteCount, charEnd);
}
buffer2[0] = *(bytes - 1);
if (fallbackBuffer.InternalFallback(buffer2, bytes, ref chars))
{
continue;
}
bytes--;
fallbackBuffer.InternalReset();
base.ThrowCharsOverflow(decoder, bytes == numPtr2);
break;
}
if (chars >= charEnd)
{
bytes--;
base.ThrowCharsOverflow(decoder, bytes == numPtr2);
break;
}
chars[0] = ch3;
chars++;
}
if (decoder != null)
{
decoder.m_bytesUsed = (int)((long)((bytes - numPtr2) / 1));
}
return((int)((long)((chars - chPtr) / 2)));
}
public void Reset ()
{
DecoderReplacementFallback f = new DecoderReplacementFallback ("X");
DecoderReplacementFallbackBuffer b = new DecoderReplacementFallbackBuffer (f);
b.Fallback (new byte [0], 0);
Assert.AreEqual (1, b.Remaining, "#1");
b.Reset ();
Assert.AreEqual (0, b.Remaining, "#2");
b.Fallback (new byte [0], 0); // do not raise an error
b.Reset ();
Assert.AreEqual (0, (int) b.GetNextChar (), "#3");
}
public DecoderTestFallbackBuffer (DecoderReplacementFallback fallback, FallbackDelegate fallbackAction)
{
this.fallbackAction = fallbackAction;
buffer = new DecoderReplacementFallbackBuffer (fallback);
}
