internal override unsafe int GetCharCount(byte *bytes, int count, DecoderNLS decoder) { DecoderReplacementFallback replacementFallback = decoder != null ? decoder.Fallback as DecoderReplacementFallback : this.DecoderFallback as DecoderReplacementFallback; if (replacementFallback != null && replacementFallback.MaxCharCount == 1) { return(count); } DecoderFallbackBuffer decoderFallbackBuffer = (DecoderFallbackBuffer)null; int num1 = count; byte[] bytes1 = new byte[1]; byte * numPtr = bytes + count; while (bytes < numPtr) { byte num2 = *bytes; ++bytes; if ((int)num2 >= 128) { if (decoderFallbackBuffer == null) { decoderFallbackBuffer = decoder != null ? decoder.FallbackBuffer : this.DecoderFallback.CreateFallbackBuffer(); decoderFallbackBuffer.InternalInitialize(numPtr - count, (char *)null); } bytes1[0] = num2; num1 = num1 - 1 + decoderFallbackBuffer.InternalFallback(bytes1, bytes); } } return(num1); }
internal override unsafe int GetCharCount(byte *bytes, int count, DecoderNLS decoder) { base.CheckMemorySection(); bool isMicrosoftBestFitFallback = false; 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))) { return(count); } DecoderFallbackBuffer fallbackBuffer = null; int num = count; byte[] buffer2 = new byte[1]; byte * numPtr = bytes + count; while (bytes < numPtr) { char ch = this.mapBytesToUnicode[bytes[0]]; bytes++; if (ch == 0xfffd) { if (fallbackBuffer == null) { if (decoder == null) { fallbackBuffer = base.DecoderFallback.CreateFallbackBuffer(); } else { fallbackBuffer = decoder.FallbackBuffer; } fallbackBuffer.InternalInitialize(numPtr - count, null); } buffer2[0] = *(bytes - 1); num--; num += fallbackBuffer.InternalFallback(buffer2, bytes); } } return(num); }
internal unsafe override int GetCharCount(byte *bytes, int count, DecoderNLS decoder) { base.CheckMemorySection(); DecoderReplacementFallback decoderReplacementFallback; bool isMicrosoftBestFitFallback; if (decoder == null) { decoderReplacementFallback = (base.DecoderFallback as DecoderReplacementFallback); isMicrosoftBestFitFallback = base.DecoderFallback.IsMicrosoftBestFitFallback; } else { decoderReplacementFallback = (decoder.Fallback as DecoderReplacementFallback); isMicrosoftBestFitFallback = decoder.Fallback.IsMicrosoftBestFitFallback; } if (isMicrosoftBestFitFallback || (decoderReplacementFallback != null && decoderReplacementFallback.MaxCharCount == 1)) { return(count); } DecoderFallbackBuffer decoderFallbackBuffer = null; int num = count; byte[] array = new byte[1]; byte * ptr = bytes + count; while (bytes < ptr) { char c = this.mapBytesToUnicode[*bytes]; bytes++; if (c == '�') { if (decoderFallbackBuffer == null) { if (decoder == null) { decoderFallbackBuffer = base.DecoderFallback.CreateFallbackBuffer(); } else { decoderFallbackBuffer = decoder.FallbackBuffer; } decoderFallbackBuffer.InternalInitialize(ptr - count, null); } array[0] = *(bytes - 1); num--; num += decoderFallbackBuffer.InternalFallback(array, bytes); } } return(num); }
internal override unsafe int GetCharCount(byte *bytes, int count, DecoderNLS decoder) { DecoderReplacementFallback decoderFallback = null; if (decoder == null) { decoderFallback = base.DecoderFallback as DecoderReplacementFallback; } else { decoderFallback = decoder.Fallback as DecoderReplacementFallback; } if ((decoderFallback != null) && (decoderFallback.MaxCharCount == 1)) { return(count); } DecoderFallbackBuffer fallbackBuffer = null; int num = count; byte[] buffer2 = new byte[1]; byte * numPtr = bytes + count; 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 - count, null); } buffer2[0] = num2; num--; num += fallbackBuffer.InternalFallback(buffer2, bytes); } } return(num); }
internal unsafe override int GetCharCount(byte *bytes, int count, DecoderNLS decoder) { DecoderReplacementFallback decoderReplacementFallback; if (decoder == null) { decoderReplacementFallback = (base.DecoderFallback as DecoderReplacementFallback); } else { decoderReplacementFallback = (decoder.Fallback as DecoderReplacementFallback); } if (decoderReplacementFallback != null && decoderReplacementFallback.MaxCharCount == 1) { return(count); } DecoderFallbackBuffer decoderFallbackBuffer = null; int num = count; byte[] array = new byte[1]; byte * ptr = bytes + count; while (bytes < ptr) { byte b = *bytes; bytes++; if (b >= 128) { if (decoderFallbackBuffer == null) { if (decoder == null) { decoderFallbackBuffer = base.DecoderFallback.CreateFallbackBuffer(); } else { decoderFallbackBuffer = decoder.FallbackBuffer; } decoderFallbackBuffer.InternalInitialize(ptr - count, null); } array[0] = b; num--; num += decoderFallbackBuffer.InternalFallback(array, bytes); } } return(num); }
internal override unsafe int GetCharCount(byte *bytes, int count, DecoderNLS decoder) { this.CheckMemorySection(); DecoderReplacementFallback replacementFallback; bool microsoftBestFitFallback; if (decoder == null) { replacementFallback = this.DecoderFallback as DecoderReplacementFallback; microsoftBestFitFallback = this.DecoderFallback.IsMicrosoftBestFitFallback; } else { replacementFallback = decoder.Fallback as DecoderReplacementFallback; microsoftBestFitFallback = decoder.Fallback.IsMicrosoftBestFitFallback; } if (microsoftBestFitFallback || replacementFallback != null && replacementFallback.MaxCharCount == 1) { return(count); } DecoderFallbackBuffer decoderFallbackBuffer = (DecoderFallbackBuffer)null; int num1 = count; byte[] bytes1 = new byte[1]; byte * numPtr = bytes + count; while (bytes < numPtr) { int num2 = (int)this.mapBytesToUnicode[*bytes]; ++bytes; int num3 = 65533; if (num2 == num3) { if (decoderFallbackBuffer == null) { decoderFallbackBuffer = decoder != null ? decoder.FallbackBuffer : this.DecoderFallback.CreateFallbackBuffer(); decoderFallbackBuffer.InternalInitialize(numPtr - count, (char *)null); } bytes1[0] = *(bytes - 1); num1 = num1 - 1 + decoderFallbackBuffer.InternalFallback(bytes1, bytes); } } return(num1); }
internal override unsafe int GetChars(byte *bytes, int byteCount, char *chars, int charCount, DecoderNLS baseDecoder) { UTF32Decoder decoder = (UTF32Decoder)baseDecoder; char * chPtr = chars; char * chPtr2 = chars + charCount; byte * numPtr = bytes; byte * numPtr2 = bytes + byteCount; int readByteCount = 0; uint iChar = 0; DecoderFallbackBuffer fallbackBuffer = null; if (decoder != null) { readByteCount = decoder.readByteCount; iChar = (uint)decoder.iChar; fallbackBuffer = baseDecoder.FallbackBuffer; } else { fallbackBuffer = base.decoderFallback.CreateFallbackBuffer(); } fallbackBuffer.InternalInitialize(bytes, chars + charCount); while (bytes < numPtr2) { if (this.bigEndian) { iChar = iChar << 8; bytes++; iChar += bytes[0]; } else { iChar = iChar >> 8; bytes++; iChar += (uint)(bytes[0] << 0x18); } readByteCount++; if (readByteCount >= 4) { readByteCount = 0; if ((iChar > 0x10ffff) || ((iChar >= 0xd800) && (iChar <= 0xdfff))) { byte[] buffer2; if (this.bigEndian) { buffer2 = new byte[] { (byte)(iChar >> 0x18), (byte)(iChar >> 0x10), (byte)(iChar >> 8), (byte)iChar }; } else { buffer2 = new byte[] { (byte)iChar, (byte)(iChar >> 8), (byte)(iChar >> 0x10), (byte)(iChar >> 0x18) }; } if (!fallbackBuffer.InternalFallback(buffer2, bytes, ref chars)) { bytes -= 4; iChar = 0; fallbackBuffer.InternalReset(); base.ThrowCharsOverflow(decoder, chars == chPtr); break; } iChar = 0; } else { if (iChar >= 0x10000) { if (chars >= (chPtr2 - 1)) { bytes -= 4; iChar = 0; base.ThrowCharsOverflow(decoder, chars == chPtr); break; } chars++; chars[0] = this.GetHighSurrogate(iChar); iChar = this.GetLowSurrogate(iChar); } else if (chars >= chPtr2) { bytes -= 4; iChar = 0; base.ThrowCharsOverflow(decoder, chars == chPtr); break; } chars++; chars[0] = (char)iChar; iChar = 0; } } } if ((readByteCount > 0) && ((decoder == null) || decoder.MustFlush)) { byte[] buffer3 = new byte[readByteCount]; int num3 = readByteCount; if (!this.bigEndian) { while (num3 > 0) { buffer3[--num3] = (byte)(iChar >> 0x18); iChar = iChar << 8; } } else { while (num3 > 0) { buffer3[--num3] = (byte)iChar; iChar = iChar >> 8; } } if (!fallbackBuffer.InternalFallback(buffer3, bytes, ref chars)) { fallbackBuffer.InternalReset(); base.ThrowCharsOverflow(decoder, chars == chPtr); } else { readByteCount = 0; iChar = 0; } } if (decoder != null) { decoder.iChar = (int)iChar; decoder.readByteCount = readByteCount; decoder.m_bytesUsed = (int)((long)((bytes - numPtr) / 1)); } return((int)((long)((chars - chPtr) / 2))); }
internal override unsafe int GetCharCount(byte *bytes, int count, DecoderNLS baseDecoder) { UTF32Decoder decoder = (UTF32Decoder)baseDecoder; int num = 0; byte * numPtr = bytes + count; byte * byteStart = bytes; int readByteCount = 0; uint iChar = 0; DecoderFallbackBuffer fallbackBuffer = null; if (decoder != null) { readByteCount = decoder.readByteCount; iChar = (uint)decoder.iChar; fallbackBuffer = decoder.FallbackBuffer; } else { fallbackBuffer = base.decoderFallback.CreateFallbackBuffer(); } fallbackBuffer.InternalInitialize(byteStart, null); while ((bytes < numPtr) && (num >= 0)) { if (this.bigEndian) { iChar = iChar << 8; bytes++; iChar += bytes[0]; } else { iChar = iChar >> 8; bytes++; iChar += (uint)(bytes[0] << 0x18); } readByteCount++; if (readByteCount >= 4) { readByteCount = 0; if ((iChar > 0x10ffff) || ((iChar >= 0xd800) && (iChar <= 0xdfff))) { byte[] buffer2; if (this.bigEndian) { buffer2 = new byte[] { (byte)(iChar >> 0x18), (byte)(iChar >> 0x10), (byte)(iChar >> 8), (byte)iChar }; } else { buffer2 = new byte[] { (byte)iChar, (byte)(iChar >> 8), (byte)(iChar >> 0x10), (byte)(iChar >> 0x18) }; } num += fallbackBuffer.InternalFallback(buffer2, bytes); iChar = 0; } else { if (iChar >= 0x10000) { num++; } num++; iChar = 0; } } } if ((readByteCount > 0) && ((decoder == null) || decoder.MustFlush)) { byte[] buffer3 = new byte[readByteCount]; if (!this.bigEndian) { while (readByteCount > 0) { buffer3[--readByteCount] = (byte)(iChar >> 0x18); iChar = iChar << 8; } } else { while (readByteCount > 0) { buffer3[--readByteCount] = (byte)iChar; iChar = iChar >> 8; } } num += fallbackBuffer.InternalFallback(buffer3, bytes); } if (num < 0) { throw new ArgumentOutOfRangeException("count", Environment.GetResourceString("ArgumentOutOfRange_GetByteCountOverflow")); } return(num); }
internal override unsafe int GetChars(byte *bytes, int byteCount, char *chars, int charCount, DecoderNLS baseDecoder) { base.CheckMemorySection(); DBCSDecoder decoder = (DBCSDecoder)baseDecoder; byte * numPtr = bytes; byte * numPtr2 = bytes + byteCount; char * chPtr = chars; char * charEnd = chars + charCount; bool flag = false; DecoderFallbackBuffer fallbackBuffer = null; if ((decoder != null) && (decoder.bLeftOver > 0)) { if (byteCount == 0) { if (!decoder.MustFlush) { return(0); } fallbackBuffer = decoder.FallbackBuffer; fallbackBuffer.InternalInitialize(bytes, charEnd); byte[] buffer2 = new byte[] { decoder.bLeftOver }; if (!fallbackBuffer.InternalFallback(buffer2, bytes, ref chars)) { base.ThrowCharsOverflow(decoder, true); } decoder.bLeftOver = 0; return((int)((long)((chars - chPtr) / 2))); } int index = decoder.bLeftOver << 8; index |= bytes[0]; bytes++; char ch = this.mapBytesToUnicode[index]; if ((ch == '\0') && (index != 0)) { fallbackBuffer = decoder.FallbackBuffer; fallbackBuffer.InternalInitialize(numPtr2 - byteCount, charEnd); byte[] buffer3 = new byte[] { (byte)(index >> 8), (byte)index }; if (!fallbackBuffer.InternalFallback(buffer3, bytes, ref chars)) { base.ThrowCharsOverflow(decoder, true); } } else { if (chars >= charEnd) { base.ThrowCharsOverflow(decoder, true); } chars++; chars[0] = ch; } } while (bytes < numPtr2) { int num2 = bytes[0]; bytes++; char ch2 = this.mapBytesToUnicode[num2]; if (ch2 == 0xfffe) { if (bytes < numPtr2) { num2 = num2 << 8; num2 |= bytes[0]; bytes++; ch2 = this.mapBytesToUnicode[num2]; } else if ((decoder == null) || decoder.MustFlush) { ch2 = '\0'; } else { flag = true; decoder.bLeftOver = (byte)num2; break; } } if ((ch2 == '\0') && (num2 != 0)) { if (fallbackBuffer == null) { if (decoder == null) { fallbackBuffer = base.DecoderFallback.CreateFallbackBuffer(); } else { fallbackBuffer = decoder.FallbackBuffer; } fallbackBuffer.InternalInitialize(numPtr2 - byteCount, charEnd); } byte[] buffer4 = null; if (num2 < 0x100) { buffer4 = new byte[] { (byte)num2 }; } else { buffer4 = new byte[] { (byte)(num2 >> 8), (byte)num2 }; } if (fallbackBuffer.InternalFallback(buffer4, bytes, ref chars)) { continue; } bytes -= buffer4.Length; fallbackBuffer.InternalReset(); base.ThrowCharsOverflow(decoder, bytes == numPtr); break; } if (chars >= charEnd) { bytes--; if (num2 >= 0x100) { bytes--; } base.ThrowCharsOverflow(decoder, bytes == numPtr); break; } chars++; chars[0] = ch2; } if (decoder != null) { if (!flag) { decoder.bLeftOver = 0; } decoder.m_bytesUsed = (int)((long)((bytes - numPtr) / 1)); } return((int)((long)((chars - chPtr) / 2))); }
internal override unsafe int GetChars(byte *bytes, int byteCount, char *chars, int charCount, DecoderNLS decoder) { this.CheckMemorySection(); byte *numPtr1 = bytes + byteCount; byte *numPtr2 = bytes; char *chPtr = chars; DecoderReplacementFallback replacementFallback; bool microsoftBestFitFallback; if (decoder == null) { replacementFallback = this.DecoderFallback as DecoderReplacementFallback; microsoftBestFitFallback = this.DecoderFallback.IsMicrosoftBestFitFallback; } else { replacementFallback = decoder.Fallback as DecoderReplacementFallback; microsoftBestFitFallback = decoder.Fallback.IsMicrosoftBestFitFallback; } if (microsoftBestFitFallback || replacementFallback != null && replacementFallback.MaxCharCount == 1) { char ch1 = replacementFallback != null ? replacementFallback.DefaultString[0] : '?'; if (charCount < byteCount) { this.ThrowCharsOverflow(decoder, charCount < 1); numPtr1 = bytes + charCount; } while (bytes < numPtr1) { char ch2; if (microsoftBestFitFallback) { if (this.arrayBytesBestFit == null) { this.ReadBestFitTable(); } ch2 = this.arrayBytesBestFit[(int)*bytes]; } else { ch2 = this.mapBytesToUnicode[*bytes]; } ++bytes; *chars = (int)ch2 != 65533 ? ch2 : ch1; chars += 2; } 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) { char ch = this.mapBytesToUnicode[*bytes]; ++bytes; if ((int)ch == 65533) { if (decoderFallbackBuffer == null) { decoderFallbackBuffer = decoder != null ? decoder.FallbackBuffer : this.DecoderFallback.CreateFallbackBuffer(); decoderFallbackBuffer.InternalInitialize(numPtr1 - byteCount, charEnd); } bytes1[0] = *(bytes - 1); if (!decoderFallbackBuffer.InternalFallback(bytes1, bytes, ref chars)) { --bytes; decoderFallbackBuffer.InternalReset(); this.ThrowCharsOverflow(decoder, bytes == numPtr2); break; } } else { if (chars >= charEnd) { --bytes; this.ThrowCharsOverflow(decoder, bytes == numPtr2); break; } *chars = ch; chars += 2; } } if (decoder != null) { decoder.m_bytesUsed = (int)(bytes - numPtr2); } return((int)(chars - chPtr)); }
// This is internal and called by something else, internal override unsafe int GetCharCount(byte *bytes, int count, DecoderNLS decoder) { // Just assert, we're called internally so these should be safe, checked already Debug.Assert(bytes != null, "[ASCIIEncoding.GetCharCount]bytes is null"); Debug.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; Debug.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 Debug.Assert(fallbackBuffer == null || fallbackBuffer.Remaining == 0, "[ASCIIEncoding.GetCharCount]Expected Empty fallback buffer"); // Converted sequence is same length as input return(charCount); }
[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 GetCharCount(byte *bytes, int count, DecoderNLS baseDecoder) { Debug.Assert(bytes != null, "[UTF32Encoding.GetCharCount]bytes!=null"); Debug.Assert(count >= 0, "[UTF32Encoding.GetCharCount]count >=0"); UTF32Decoder decoder = (UTF32Decoder)baseDecoder; // None so far! int charCount = 0; byte *end = bytes + count; byte *byteStart = bytes; // Set up decoder int readCount = 0; uint iChar = 0; // For fallback we may need a fallback buffer DecoderFallbackBuffer fallbackBuffer = null; // See if there's anything in our decoder if (decoder != null) { readCount = decoder.readByteCount; iChar = (uint)decoder.iChar; fallbackBuffer = decoder.FallbackBuffer; // Shouldn't have anything in fallback buffer for GetCharCount // (don't have to check m_throwOnOverflow for chars or count) Debug.Assert(fallbackBuffer.Remaining == 0, "[UTF32Encoding.GetCharCount]Expected empty fallback buffer at start"); } else { fallbackBuffer = this.decoderFallback.CreateFallbackBuffer(); } // Set our internal fallback interesting things. fallbackBuffer.InternalInitialize(byteStart, null); // Loop through our input, 4 characters at a time! while (bytes < end && charCount >= 0) { // Get our next character if (bigEndian) { // Scoot left and add it to the bottom iChar <<= 8; iChar += *(bytes++); } else { // Scoot right and add it to the top iChar >>= 8; iChar += (uint)(*(bytes++)) << 24; } readCount++; // See if we have all the bytes yet if (readCount < 4) { continue; } // Have the bytes readCount = 0; // See if its valid to encode if (iChar > 0x10FFFF || (iChar >= 0xD800 && iChar <= 0xDFFF)) { // Need to fall back these 4 bytes byte[] fallbackBytes; if (bigEndian) { fallbackBytes = new byte[] { unchecked ((byte)(iChar >> 24)), unchecked ((byte)(iChar >> 16)), unchecked ((byte)(iChar >> 8)), unchecked ((byte)(iChar)) }; } else { fallbackBytes = new byte[] { unchecked ((byte)(iChar)), unchecked ((byte)(iChar >> 8)), unchecked ((byte)(iChar >> 16)), unchecked ((byte)(iChar >> 24)) }; } charCount += fallbackBuffer.InternalFallback(fallbackBytes, bytes); // Ignore the illegal character iChar = 0; continue; } // Ok, we have something we can add to our output if (iChar >= 0x10000) { // Surrogates take 2 charCount++; } // Add the rest of the surrogate or our normal character charCount++; // iChar is back to 0 iChar = 0; } // See if we have something left over that has to be decoded if (readCount > 0 && (decoder == null || decoder.MustFlush)) { // Oops, there's something left over with no place to go. byte[] fallbackBytes = new byte[readCount]; if (bigEndian) { while (readCount > 0) { fallbackBytes[--readCount] = unchecked ((byte)iChar); iChar >>= 8; } } else { while (readCount > 0) { fallbackBytes[--readCount] = unchecked ((byte)(iChar >> 24)); iChar <<= 8; } } charCount += fallbackBuffer.InternalFallback(fallbackBytes, bytes); } // Check for overflows. if (charCount < 0) { throw new ArgumentOutOfRangeException(nameof(count), Environment.GetResourceString("ArgumentOutOfRange_GetByteCountOverflow")); } // Shouldn't have anything in fallback buffer for GetCharCount // (don't have to check m_throwOnOverflow for chars or count) Debug.Assert(fallbackBuffer.Remaining == 0, "[UTF32Encoding.GetCharCount]Expected empty fallback buffer at end"); // Return our count return(charCount); }
internal override unsafe int GetCharCount(byte *bytes, int count, DecoderNLS baseDecoder) { this.CheckMemorySection(); DBCSCodePageEncoding.DBCSDecoder dbcsDecoder = (DBCSCodePageEncoding.DBCSDecoder)baseDecoder; DecoderFallbackBuffer decoderFallbackBuffer = (DecoderFallbackBuffer)null; byte *numPtr = bytes + count; int num1 = count; if (dbcsDecoder != null && (int)dbcsDecoder.bLeftOver > 0) { if (count == 0) { if (!dbcsDecoder.MustFlush) { return(0); } DecoderFallbackBuffer fallbackBuffer = dbcsDecoder.FallbackBuffer; fallbackBuffer.InternalInitialize(bytes, (char *)null); byte[] bytes1 = new byte[1] { dbcsDecoder.bLeftOver }; return(fallbackBuffer.InternalFallback(bytes1, bytes)); } int index = (int)dbcsDecoder.bLeftOver << 8 | (int)*bytes; ++bytes; if ((int)this.mapBytesToUnicode[index] == 0 && index != 0) { int num2 = num1 - 1; decoderFallbackBuffer = dbcsDecoder.FallbackBuffer; decoderFallbackBuffer.InternalInitialize(numPtr - count, (char *)null); byte[] bytes1 = new byte[2] { (byte)(index >> 8), (byte)index }; num1 = num2 + decoderFallbackBuffer.InternalFallback(bytes1, bytes); } } while (bytes < numPtr) { int index = (int)*bytes; ++bytes; char ch = this.mapBytesToUnicode[index]; if ((int)ch == 65534) { --num1; if (bytes < numPtr) { index = index << 8 | (int)*bytes; ++bytes; ch = this.mapBytesToUnicode[index]; } else if (dbcsDecoder == null || dbcsDecoder.MustFlush) { ++num1; ch = char.MinValue; } else { break; } } if ((int)ch == 0 && index != 0) { if (decoderFallbackBuffer == null) { decoderFallbackBuffer = dbcsDecoder != null ? dbcsDecoder.FallbackBuffer : this.DecoderFallback.CreateFallbackBuffer(); decoderFallbackBuffer.InternalInitialize(numPtr - count, (char *)null); } int num2 = num1 - 1; byte[] bytes1; if (index < 256) { bytes1 = new byte[1] { (byte)index } } ; else { bytes1 = new byte[2] { (byte)(index >> 8), (byte)index } }; num1 = num2 + decoderFallbackBuffer.InternalFallback(bytes1, bytes); } } return(num1); }
internal unsafe override int GetChars(byte *bytes, int byteCount, char *chars, int charCount, DecoderNLS decoder) { base.CheckMemorySection(); byte *ptr = bytes + byteCount; byte *ptr2 = bytes; char *ptr3 = chars; DecoderReplacementFallback decoderReplacementFallback; bool isMicrosoftBestFitFallback; if (decoder == null) { decoderReplacementFallback = (base.DecoderFallback as DecoderReplacementFallback); isMicrosoftBestFitFallback = base.DecoderFallback.IsMicrosoftBestFitFallback; } else { decoderReplacementFallback = (decoder.Fallback as DecoderReplacementFallback); isMicrosoftBestFitFallback = decoder.Fallback.IsMicrosoftBestFitFallback; } if (isMicrosoftBestFitFallback || (decoderReplacementFallback != null && decoderReplacementFallback.MaxCharCount == 1)) { char c; if (decoderReplacementFallback == null) { c = '?'; } else { c = decoderReplacementFallback.DefaultString[0]; } if (charCount < byteCount) { base.ThrowCharsOverflow(decoder, charCount < 1); ptr = bytes + charCount; } while (bytes < ptr) { char c2; if (isMicrosoftBestFitFallback) { if (this.arrayBytesBestFit == null) { this.ReadBestFitTable(); } c2 = this.arrayBytesBestFit[(int)(*bytes)]; } else { c2 = this.mapBytesToUnicode[*bytes]; } bytes++; if (c2 == '�') { *chars = c; } else { *chars = c2; } chars++; } if (decoder != null) { decoder.m_bytesUsed = (int)((long)(bytes - ptr2)); } return((int)((long)(chars - ptr3))); } DecoderFallbackBuffer decoderFallbackBuffer = null; byte[] array = new byte[1]; char * ptr4 = chars + charCount; while (bytes < ptr) { char c3 = this.mapBytesToUnicode[*bytes]; bytes++; if (c3 == '�') { if (decoderFallbackBuffer == null) { if (decoder == null) { decoderFallbackBuffer = base.DecoderFallback.CreateFallbackBuffer(); } else { decoderFallbackBuffer = decoder.FallbackBuffer; } decoderFallbackBuffer.InternalInitialize(ptr - byteCount, ptr4); } array[0] = *(bytes - 1); if (!decoderFallbackBuffer.InternalFallback(array, bytes, ref chars)) { bytes--; decoderFallbackBuffer.InternalReset(); base.ThrowCharsOverflow(decoder, bytes == ptr2); break; } } else { if (chars >= ptr4) { bytes--; base.ThrowCharsOverflow(decoder, bytes == ptr2); break; } *chars = c3; chars++; } } if (decoder != null) { decoder.m_bytesUsed = (int)((long)(bytes - ptr2)); } return((int)((long)(chars - ptr3))); }
internal override unsafe int GetChars(byte *bytes, int byteCount, char *chars, int charCount, DecoderNLS baseDecoder) { this.CheckMemorySection(); DBCSCodePageEncoding.DBCSDecoder dbcsDecoder = (DBCSCodePageEncoding.DBCSDecoder)baseDecoder; byte *numPtr1 = bytes; byte *numPtr2 = bytes + byteCount; char *chPtr = chars; char *charEnd = chars + charCount; bool flag = false; DecoderFallbackBuffer decoderFallbackBuffer = (DecoderFallbackBuffer)null; if (dbcsDecoder != null && (int)dbcsDecoder.bLeftOver > 0) { if (byteCount == 0) { if (!dbcsDecoder.MustFlush) { return(0); } DecoderFallbackBuffer fallbackBuffer = dbcsDecoder.FallbackBuffer; fallbackBuffer.InternalInitialize(bytes, charEnd); byte[] bytes1 = new byte[1] { dbcsDecoder.bLeftOver }; if (!fallbackBuffer.InternalFallback(bytes1, bytes, ref chars)) { this.ThrowCharsOverflow((DecoderNLS)dbcsDecoder, true); } dbcsDecoder.bLeftOver = (byte)0; return((int)(chars - chPtr)); } int index = (int)dbcsDecoder.bLeftOver << 8 | (int)*bytes; ++bytes; char ch = this.mapBytesToUnicode[index]; if ((int)ch == 0 && index != 0) { decoderFallbackBuffer = dbcsDecoder.FallbackBuffer; decoderFallbackBuffer.InternalInitialize(numPtr2 - byteCount, charEnd); byte[] bytes1 = new byte[2] { (byte)(index >> 8), (byte)index }; if (!decoderFallbackBuffer.InternalFallback(bytes1, bytes, ref chars)) { this.ThrowCharsOverflow((DecoderNLS)dbcsDecoder, true); } } else { if (chars >= charEnd) { this.ThrowCharsOverflow((DecoderNLS)dbcsDecoder, true); } *chars++ = ch; } } while (bytes < numPtr2) { int index = (int)*bytes; ++bytes; char ch = this.mapBytesToUnicode[index]; if ((int)ch == 65534) { if (bytes < numPtr2) { index = index << 8 | (int)*bytes; ++bytes; ch = this.mapBytesToUnicode[index]; } else if (dbcsDecoder == null || dbcsDecoder.MustFlush) { ch = char.MinValue; } else { flag = true; dbcsDecoder.bLeftOver = (byte)index; break; } } if ((int)ch == 0 && index != 0) { if (decoderFallbackBuffer == null) { decoderFallbackBuffer = dbcsDecoder != null ? dbcsDecoder.FallbackBuffer : this.DecoderFallback.CreateFallbackBuffer(); decoderFallbackBuffer.InternalInitialize(numPtr2 - byteCount, charEnd); } byte[] bytes1; if (index < 256) { bytes1 = new byte[1] { (byte)index } } ; else { bytes1 = new byte[2] { (byte)(index >> 8), (byte)index } }; if (!decoderFallbackBuffer.InternalFallback(bytes1, bytes, ref chars)) { bytes -= bytes1.Length; decoderFallbackBuffer.InternalReset(); this.ThrowCharsOverflow((DecoderNLS)dbcsDecoder, bytes == numPtr1); break; } } else { if (chars >= charEnd) { --bytes; if (index >= 256) { --bytes; } this.ThrowCharsOverflow((DecoderNLS)dbcsDecoder, bytes == numPtr1); break; } *chars++ = ch; } } if (dbcsDecoder != null) { if (!flag) { dbcsDecoder.bLeftOver = (byte)0; } dbcsDecoder.m_bytesUsed = (int)(bytes - numPtr1); } return((int)(chars - chPtr)); }
internal unsafe override int GetChars(byte *bytes, int byteCount, char *chars, int charCount, DecoderNLS decoder) { byte *ptr = bytes + byteCount; byte *ptr2 = bytes; char *ptr3 = chars; DecoderReplacementFallback decoderReplacementFallback; if (decoder == null) { decoderReplacementFallback = (base.DecoderFallback as DecoderReplacementFallback); } else { decoderReplacementFallback = (decoder.Fallback as DecoderReplacementFallback); } if (decoderReplacementFallback != null && decoderReplacementFallback.MaxCharCount == 1) { char c = decoderReplacementFallback.DefaultString[0]; if (charCount < byteCount) { base.ThrowCharsOverflow(decoder, charCount < 1); ptr = bytes + charCount; } while (bytes < ptr) { byte b = *(bytes++); if (b >= 128) { *(chars++) = c; } else { *(chars++) = (char)b; } } if (decoder != null) { decoder.m_bytesUsed = (int)((long)(bytes - ptr2)); } return((int)((long)(chars - ptr3))); } DecoderFallbackBuffer decoderFallbackBuffer = null; byte[] array = new byte[1]; char * ptr4 = chars + charCount; while (bytes < ptr) { byte b2 = *bytes; bytes++; if (b2 >= 128) { if (decoderFallbackBuffer == null) { if (decoder == null) { decoderFallbackBuffer = base.DecoderFallback.CreateFallbackBuffer(); } else { decoderFallbackBuffer = decoder.FallbackBuffer; } decoderFallbackBuffer.InternalInitialize(ptr - byteCount, ptr4); } array[0] = b2; if (!decoderFallbackBuffer.InternalFallback(array, bytes, ref chars)) { bytes--; decoderFallbackBuffer.InternalReset(); base.ThrowCharsOverflow(decoder, chars == ptr3); break; } } else { if (chars >= ptr4) { bytes--; base.ThrowCharsOverflow(decoder, chars == ptr3); break; } *chars = (char)b2; chars++; } } if (decoder != null) { decoder.m_bytesUsed = (int)((long)(bytes - ptr2)); } return((int)((long)(chars - ptr3))); }
internal unsafe override int GetChars(byte *bytes, int byteCount, char *chars, int charCount, DecoderNLS baseDecoder) { base.CheckMemorySection(); DBCSCodePageEncoding.DBCSDecoder dbcsdecoder = (DBCSCodePageEncoding.DBCSDecoder)baseDecoder; byte *ptr = bytes; byte *ptr2 = bytes + byteCount; char *ptr3 = chars; char *ptr4 = chars + charCount; bool flag = false; DecoderFallbackBuffer decoderFallbackBuffer = null; if (dbcsdecoder != null && dbcsdecoder.bLeftOver > 0) { if (byteCount == 0) { if (!dbcsdecoder.MustFlush) { return(0); } decoderFallbackBuffer = dbcsdecoder.FallbackBuffer; decoderFallbackBuffer.InternalInitialize(bytes, ptr4); byte[] bytes2 = new byte[] { dbcsdecoder.bLeftOver }; if (!decoderFallbackBuffer.InternalFallback(bytes2, bytes, ref chars)) { base.ThrowCharsOverflow(dbcsdecoder, true); } dbcsdecoder.bLeftOver = 0; return((int)((long)(chars - ptr3))); } else { int num = (int)dbcsdecoder.bLeftOver << 8; num |= (int)(*bytes); bytes++; char c = this.mapBytesToUnicode[num]; if (c == '\0' && num != 0) { decoderFallbackBuffer = dbcsdecoder.FallbackBuffer; decoderFallbackBuffer.InternalInitialize(ptr2 - byteCount, ptr4); byte[] bytes3 = new byte[] { (byte)(num >> 8), (byte)num }; if (!decoderFallbackBuffer.InternalFallback(bytes3, bytes, ref chars)) { base.ThrowCharsOverflow(dbcsdecoder, true); } } else { if (chars >= ptr4) { base.ThrowCharsOverflow(dbcsdecoder, true); } *(chars++) = c; } } } while (bytes < ptr2) { int num2 = (int)(*bytes); bytes++; char c2 = this.mapBytesToUnicode[num2]; if (c2 == '') { if (bytes < ptr2) { num2 <<= 8; num2 |= (int)(*bytes); bytes++; c2 = this.mapBytesToUnicode[num2]; } else { if (dbcsdecoder != null && !dbcsdecoder.MustFlush) { flag = true; dbcsdecoder.bLeftOver = (byte)num2; break; } c2 = '\0'; } } if (c2 == '\0' && num2 != 0) { if (decoderFallbackBuffer == null) { if (dbcsdecoder == null) { decoderFallbackBuffer = base.DecoderFallback.CreateFallbackBuffer(); } else { decoderFallbackBuffer = dbcsdecoder.FallbackBuffer; } decoderFallbackBuffer.InternalInitialize(ptr2 - byteCount, ptr4); } byte[] array; if (num2 < 256) { array = new byte[] { (byte)num2 }; } else { array = new byte[] { (byte)(num2 >> 8), (byte)num2 }; } if (!decoderFallbackBuffer.InternalFallback(array, bytes, ref chars)) { bytes -= array.Length; decoderFallbackBuffer.InternalReset(); base.ThrowCharsOverflow(dbcsdecoder, bytes == ptr); break; } } else { if (chars >= ptr4) { bytes--; if (num2 >= 256) { bytes--; } base.ThrowCharsOverflow(dbcsdecoder, bytes == ptr); break; } *(chars++) = c2; } } if (dbcsdecoder != null) { if (!flag) { dbcsdecoder.bLeftOver = 0; } dbcsdecoder.m_bytesUsed = (int)((long)(bytes - ptr)); } return((int)((long)(chars - ptr3))); }
internal unsafe override int GetCharCount(byte *bytes, int count, DecoderNLS baseDecoder) { base.CheckMemorySection(); DBCSCodePageEncoding.DBCSDecoder dbcsdecoder = (DBCSCodePageEncoding.DBCSDecoder)baseDecoder; DecoderFallbackBuffer decoderFallbackBuffer = null; byte *ptr = bytes + count; int num = count; if (dbcsdecoder != null && dbcsdecoder.bLeftOver > 0) { if (count == 0) { if (!dbcsdecoder.MustFlush) { return(0); } decoderFallbackBuffer = dbcsdecoder.FallbackBuffer; decoderFallbackBuffer.InternalInitialize(bytes, null); byte[] bytes2 = new byte[] { dbcsdecoder.bLeftOver }; return(decoderFallbackBuffer.InternalFallback(bytes2, bytes)); } else { int num2 = (int)dbcsdecoder.bLeftOver << 8; num2 |= (int)(*bytes); bytes++; if (this.mapBytesToUnicode[num2] == '\0' && num2 != 0) { num--; decoderFallbackBuffer = dbcsdecoder.FallbackBuffer; decoderFallbackBuffer.InternalInitialize(ptr - count, null); byte[] bytes3 = new byte[] { (byte)(num2 >> 8), (byte)num2 }; num += decoderFallbackBuffer.InternalFallback(bytes3, bytes); } } } while (bytes < ptr) { int num3 = (int)(*bytes); bytes++; char c = this.mapBytesToUnicode[num3]; if (c == '') { num--; if (bytes < ptr) { num3 <<= 8; num3 |= (int)(*bytes); bytes++; c = this.mapBytesToUnicode[num3]; } else { if (dbcsdecoder != null && !dbcsdecoder.MustFlush) { break; } num++; c = '\0'; } } if (c == '\0' && num3 != 0) { if (decoderFallbackBuffer == null) { if (dbcsdecoder == null) { decoderFallbackBuffer = base.DecoderFallback.CreateFallbackBuffer(); } else { decoderFallbackBuffer = dbcsdecoder.FallbackBuffer; } decoderFallbackBuffer.InternalInitialize(ptr - count, null); } num--; byte[] bytes4; if (num3 < 256) { bytes4 = new byte[] { (byte)num3 }; } else { bytes4 = new byte[] { (byte)(num3 >> 8), (byte)num3 }; } num += decoderFallbackBuffer.InternalFallback(bytes4, bytes); } } return(num); }
// 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) { // 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; } 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)) { 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) { 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); }
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))); }
internal override unsafe int GetChars(byte *bytes, int byteCount, char *chars, int charCount, DecoderNLS baseDecoder) { Debug.Assert(chars != null, "[UTF32Encoding.GetChars]chars!=null"); Debug.Assert(bytes != null, "[UTF32Encoding.GetChars]bytes!=null"); Debug.Assert(byteCount >= 0, "[UTF32Encoding.GetChars]byteCount >=0"); Debug.Assert(charCount >= 0, "[UTF32Encoding.GetChars]charCount >=0"); UTF32Decoder decoder = (UTF32Decoder)baseDecoder; // None so far! char *charStart = chars; char *charEnd = chars + charCount; byte *byteStart = bytes; byte *byteEnd = bytes + byteCount; // See if there's anything in our decoder (but don't clear it yet) int readCount = 0; uint iChar = 0; // For fallback we may need a fallback buffer DecoderFallbackBuffer fallbackBuffer = null; char *charsForFallback; // See if there's anything in our decoder if (decoder != null) { readCount = decoder.readByteCount; iChar = (uint)decoder.iChar; fallbackBuffer = baseDecoder.FallbackBuffer; // Shouldn't have anything in fallback buffer for GetChars // (don't have to check m_throwOnOverflow for chars) Debug.Assert(fallbackBuffer.Remaining == 0, "[UTF32Encoding.GetChars]Expected empty fallback buffer at start"); } else { fallbackBuffer = this.decoderFallback.CreateFallbackBuffer(); } // Set our internal fallback interesting things. fallbackBuffer.InternalInitialize(bytes, chars + charCount); // Loop through our input, 4 characters at a time! while (bytes < byteEnd) { // Get our next character if (bigEndian) { // Scoot left and add it to the bottom iChar <<= 8; iChar += *(bytes++); } else { // Scoot right and add it to the top iChar >>= 8; iChar += (uint)(*(bytes++)) << 24; } readCount++; // See if we have all the bytes yet if (readCount < 4) { continue; } // Have the bytes readCount = 0; // See if its valid to encode if (iChar > 0x10FFFF || (iChar >= 0xD800 && iChar <= 0xDFFF)) { // Need to fall back these 4 bytes byte[] fallbackBytes; if (bigEndian) { fallbackBytes = new byte[] { unchecked ((byte)(iChar >> 24)), unchecked ((byte)(iChar >> 16)), unchecked ((byte)(iChar >> 8)), unchecked ((byte)(iChar)) }; } else { fallbackBytes = new byte[] { unchecked ((byte)(iChar)), unchecked ((byte)(iChar >> 8)), unchecked ((byte)(iChar >> 16)), unchecked ((byte)(iChar >> 24)) }; } // Chars won't be updated unless this works. charsForFallback = chars; bool fallbackResult = fallbackBuffer.InternalFallback(fallbackBytes, bytes, ref charsForFallback); chars = charsForFallback; if (!fallbackResult) { // Couldn't fallback, throw or wait til next time // We either read enough bytes for bytes-=4 to work, or we're // going to throw in ThrowCharsOverflow because chars == charStart Debug.Assert(bytes >= byteStart + 4 || chars == charStart, "[UTF32Encoding.GetChars]Expected to have consumed bytes or throw (bad surrogate)"); bytes -= 4; // get back to where we were iChar = 0; // Remembering nothing fallbackBuffer.InternalReset(); ThrowCharsOverflow(decoder, chars == charStart); // Might throw, if no chars output break; // Stop here, didn't throw } // Ignore the illegal character iChar = 0; continue; } // Ok, we have something we can add to our output if (iChar >= 0x10000) { // Surrogates take 2 if (chars >= charEnd - 1) { // Throwing or stopping // We either read enough bytes for bytes-=4 to work, or we're // going to throw in ThrowCharsOverflow because chars == charStart Debug.Assert(bytes >= byteStart + 4 || chars == charStart, "[UTF32Encoding.GetChars]Expected to have consumed bytes or throw (surrogate)"); bytes -= 4; // get back to where we were iChar = 0; // Remembering nothing ThrowCharsOverflow(decoder, chars == charStart); // Might throw, if no chars output break; // Stop here, didn't throw } *(chars++) = GetHighSurrogate(iChar); iChar = GetLowSurrogate(iChar); } // Bounds check for normal character else if (chars >= charEnd) { // Throwing or stopping // We either read enough bytes for bytes-=4 to work, or we're // going to throw in ThrowCharsOverflow because chars == charStart Debug.Assert(bytes >= byteStart + 4 || chars == charStart, "[UTF32Encoding.GetChars]Expected to have consumed bytes or throw (normal char)"); bytes -= 4; // get back to where we were iChar = 0; // Remembering nothing ThrowCharsOverflow(decoder, chars == charStart); // Might throw, if no chars output break; // Stop here, didn't throw } // Add the rest of the surrogate or our normal character *(chars++) = (char)iChar; // iChar is back to 0 iChar = 0; } // See if we have something left over that has to be decoded if (readCount > 0 && (decoder == null || decoder.MustFlush)) { // Oops, there's something left over with no place to go. byte[] fallbackBytes = new byte[readCount]; int tempCount = readCount; if (bigEndian) { while (tempCount > 0) { fallbackBytes[--tempCount] = unchecked ((byte)iChar); iChar >>= 8; } } else { while (tempCount > 0) { fallbackBytes[--tempCount] = unchecked ((byte)(iChar >> 24)); iChar <<= 8; } } charsForFallback = chars; bool fallbackResult = fallbackBuffer.InternalFallback(fallbackBytes, bytes, ref charsForFallback); chars = charsForFallback; if (!fallbackResult) { // Couldn't fallback. fallbackBuffer.InternalReset(); ThrowCharsOverflow(decoder, chars == charStart);// Might throw, if no chars output // Stop here, didn't throw, backed up, so still nothing in buffer } else { // Don't clear our decoder unless we could fall it back. // If we caught the if above, then we're a convert() and will catch this next time. readCount = 0; iChar = 0; } } // Remember any left over stuff, clearing buffer as well for MustFlush if (decoder != null) { decoder.iChar = (int)iChar; decoder.readByteCount = readCount; decoder.m_bytesUsed = (int)(bytes - byteStart); } // Shouldn't have anything in fallback buffer for GetChars // (don't have to check m_throwOnOverflow for chars) Debug.Assert(fallbackBuffer.Remaining == 0, "[UTF32Encoding.GetChars]Expected empty fallback buffer at end"); // Return our count return((int)(chars - charStart)); }
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)); }
[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, "[SBCSCodePageEncoding.GetChars]bytes is null"); Contract.Assert(byteCount >= 0, "[SBCSCodePageEncoding.GetChars]byteCount is negative"); Contract.Assert(chars != null, "[SBCSCodePageEncoding.GetChars]chars is null"); Contract.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 = 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)) { // Try it the fast way char replacementChar; if (fallback == null) { replacementChar = '?'; // Best fit alwasy 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; // 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 = this.DecoderFallback.CreateFallbackBuffer(); } else { fallbackBuffer = decoder.FallbackBuffer; } fallbackBuffer.InternalInitialize(byteEnd - byteCount, charEnd); } // Use fallback buffer Contract.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 (!fallbackBuffer.InternalFallback(byteBuffer, bytes, ref chars)) { // May or may not throw, but we didn't get this byte bytes--; // unused byte fallbackBuffer.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) { Contract.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 Contract.Assert(fallbackBuffer == null || fallbackBuffer.Remaining == 0, "[SBCSEncoding.GetChars]Expected Empty fallback buffer at end"); return((int)(chars - charStart)); }
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))); }
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 Debug.Assert(bytes != null, "[ASCIIEncoding.GetChars]bytes is null"); Debug.Assert(byteCount >= 0, "[ASCIIEncoding.GetChars]byteCount is negative"); Debug.Assert(chars != null, "[ASCIIEncoding.GetChars]chars is null"); Debug.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; char *charsForFallback; if (decoder == null) { fallback = this.DecoderFallback as DecoderReplacementFallback; } else { fallback = decoder.Fallback as DecoderReplacementFallback; Debug.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 charsForFallback = chars; // Avoid passing chars by reference to allow it to be enregistered bool fallbackResult = fallbackBuffer.InternalFallback(byteBuffer, bytes, ref charsForFallback); chars = charsForFallback; if (!fallbackResult) { // May or may not throw, but we didn't get this byte Debug.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) { Debug.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 Debug.Assert(fallbackBuffer == null || fallbackBuffer.Remaining == 0, "[ASCIIEncoding.GetChars]Expected Empty fallback buffer"); return((int)(chars - charStart)); }
internal override unsafe int GetCharCount(byte *bytes, int count, DecoderNLS baseDecoder) { base.CheckMemorySection(); DBCSDecoder decoder = (DBCSDecoder)baseDecoder; DecoderFallbackBuffer fallbackBuffer = null; byte *numPtr = bytes + count; int num = count; if ((decoder != null) && (decoder.bLeftOver > 0)) { if (count == 0) { if (!decoder.MustFlush) { return(0); } fallbackBuffer = decoder.FallbackBuffer; fallbackBuffer.InternalInitialize(bytes, null); byte[] buffer2 = new byte[] { decoder.bLeftOver }; return(fallbackBuffer.InternalFallback(buffer2, bytes)); } int index = decoder.bLeftOver << 8; index |= bytes[0]; bytes++; if ((this.mapBytesToUnicode[index] == '\0') && (index != 0)) { num--; fallbackBuffer = decoder.FallbackBuffer; fallbackBuffer.InternalInitialize(numPtr - count, null); byte[] buffer3 = new byte[] { (byte)(index >> 8), (byte)index }; num += fallbackBuffer.InternalFallback(buffer3, bytes); } } while (bytes < numPtr) { int num3 = bytes[0]; bytes++; char ch2 = this.mapBytesToUnicode[num3]; if (ch2 == 0xfffe) { num--; if (bytes < numPtr) { num3 = num3 << 8; num3 |= bytes[0]; bytes++; ch2 = this.mapBytesToUnicode[num3]; } else { if ((decoder != null) && !decoder.MustFlush) { return(num); } num++; ch2 = '\0'; } } if ((ch2 == '\0') && (num3 != 0)) { if (fallbackBuffer == null) { if (decoder == null) { fallbackBuffer = base.DecoderFallback.CreateFallbackBuffer(); } else { fallbackBuffer = decoder.FallbackBuffer; } fallbackBuffer.InternalInitialize(numPtr - count, null); } num--; byte[] buffer4 = null; if (num3 < 0x100) { buffer4 = new byte[] { (byte)num3 }; } else { buffer4 = new byte[] { (byte)(num3 >> 8), (byte)num3 }; } num += fallbackBuffer.InternalFallback(buffer4, bytes); } } return(num); }