niko
1178 lines
48 KiB
C#
1178 lines
48 KiB
C#
using System;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Runtime.InteropServices;
|
|
|
|
namespace System.Text
|
|
{
|
|
/// <summary>Represents a UTF-8 encoding of Unicode characters.</summary>
|
|
/// <filterpriority>1</filterpriority>
|
|
// Token: 0x02000601 RID: 1537
|
|
[MonoTODO("Serialization format not compatible with .NET")]
|
|
[ComVisible(true)]
|
|
[MonoTODO("EncoderFallback is not handled")]
|
|
[Serializable]
|
|
public class UTF8Encoding : Encoding
|
|
{
|
|
/// <summary>Initializes a new instance of the <see cref="T:System.Text.UTF8Encoding" /> class.</summary>
|
|
// Token: 0x0600383B RID: 14395 RVA: 0x000C197C File Offset: 0x000BFB7C
|
|
public UTF8Encoding()
|
|
: this(false, false)
|
|
{
|
|
}
|
|
|
|
/// <summary>Initializes a new instance of the <see cref="T:System.Text.UTF8Encoding" /> class. A parameter specifies whether to provide a Unicode byte order mark.</summary>
|
|
/// <param name="encoderShouldEmitUTF8Identifier">true to specify that a Unicode byte order mark is provided; otherwise, false. </param>
|
|
// Token: 0x0600383C RID: 14396 RVA: 0x000C1988 File Offset: 0x000BFB88
|
|
public UTF8Encoding(bool encoderShouldEmitUTF8Identifier)
|
|
: this(encoderShouldEmitUTF8Identifier, false)
|
|
{
|
|
}
|
|
|
|
/// <summary>Initializes a new instance of the <see cref="T:System.Text.UTF8Encoding" /> class. Parameters specify whether to provide a Unicode byte order mark and whether to throw an exception when an invalid encoding is detected.</summary>
|
|
/// <param name="encoderShouldEmitUTF8Identifier">true to specify that a Unicode byte order mark is provided; otherwise, false. </param>
|
|
/// <param name="throwOnInvalidBytes">true to specify that an exception be thrown when an invalid encoding is detected; otherwise, false. </param>
|
|
// Token: 0x0600383D RID: 14397 RVA: 0x000C1994 File Offset: 0x000BFB94
|
|
public UTF8Encoding(bool encoderShouldEmitUTF8Identifier, bool throwOnInvalidBytes)
|
|
: base(65001)
|
|
{
|
|
this.emitIdentifier = encoderShouldEmitUTF8Identifier;
|
|
if (throwOnInvalidBytes)
|
|
{
|
|
base.SetFallbackInternal(null, DecoderFallback.ExceptionFallback);
|
|
}
|
|
else
|
|
{
|
|
base.SetFallbackInternal(null, DecoderFallback.StandardSafeFallback);
|
|
}
|
|
this.web_name = (this.body_name = (this.header_name = "utf-8"));
|
|
this.encoding_name = "Unicode (UTF-8)";
|
|
this.is_browser_save = true;
|
|
this.is_browser_display = true;
|
|
this.is_mail_news_display = true;
|
|
this.is_mail_news_save = true;
|
|
this.windows_code_page = 1200;
|
|
}
|
|
|
|
// Token: 0x0600383E RID: 14398 RVA: 0x000C1A28 File Offset: 0x000BFC28
|
|
private unsafe static int InternalGetByteCount(char[] chars, int index, int count, ref char leftOver, bool flush)
|
|
{
|
|
if (chars == null)
|
|
{
|
|
throw new ArgumentNullException("chars");
|
|
}
|
|
if (index < 0 || index > chars.Length)
|
|
{
|
|
throw new ArgumentOutOfRangeException("index", Encoding._("ArgRange_Array"));
|
|
}
|
|
if (count < 0 || count > chars.Length - index)
|
|
{
|
|
throw new ArgumentOutOfRangeException("count", Encoding._("ArgRange_Array"));
|
|
}
|
|
if (index != chars.Length)
|
|
{
|
|
fixed (char* ptr = (ref chars != null && chars.Length != 0 ? ref chars[0] : ref *null))
|
|
{
|
|
return UTF8Encoding.InternalGetByteCount(ptr + index, count, ref leftOver, flush);
|
|
}
|
|
}
|
|
if (flush && leftOver != '\0')
|
|
{
|
|
leftOver = '\0';
|
|
return 3;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// Token: 0x0600383F RID: 14399 RVA: 0x000C1ADC File Offset: 0x000BFCDC
|
|
private unsafe static int InternalGetByteCount(char* chars, int count, ref char leftOver, bool flush)
|
|
{
|
|
int num = 0;
|
|
char* ptr = chars + count;
|
|
while (chars < ptr)
|
|
{
|
|
if (leftOver == '\0')
|
|
{
|
|
while (chars < ptr)
|
|
{
|
|
if (*chars < '\u0080')
|
|
{
|
|
num++;
|
|
}
|
|
else if (*chars < 'ࠀ')
|
|
{
|
|
num += 2;
|
|
}
|
|
else if (*chars < '\ud800' || *chars > '\udfff')
|
|
{
|
|
num += 3;
|
|
}
|
|
else if (*chars <= '\udbff')
|
|
{
|
|
if (chars + 1 >= ptr || chars[1] < '\udc00' || chars[1] > '\udfff')
|
|
{
|
|
leftOver = *chars;
|
|
chars++;
|
|
break;
|
|
}
|
|
num += 4;
|
|
chars++;
|
|
}
|
|
else
|
|
{
|
|
num += 3;
|
|
leftOver = '\0';
|
|
}
|
|
chars++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (*chars >= '\udc00' && *chars <= '\udfff')
|
|
{
|
|
num += 4;
|
|
chars++;
|
|
}
|
|
else
|
|
{
|
|
num += 3;
|
|
}
|
|
leftOver = '\0';
|
|
}
|
|
}
|
|
if (flush && leftOver != '\0')
|
|
{
|
|
num += 3;
|
|
leftOver = '\0';
|
|
}
|
|
return num;
|
|
}
|
|
|
|
/// <summary>Calculates the number of bytes produced by encoding a set of characters from the specified character array.</summary>
|
|
/// <returns>The number of bytes produced by encoding the specified characters.</returns>
|
|
/// <param name="chars">The character array containing the set of characters to encode. </param>
|
|
/// <param name="index">The index of the first character to encode. </param>
|
|
/// <param name="count">The number of characters to encode. </param>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="chars" /> is null. </exception>
|
|
/// <exception cref="T:System.ArgumentOutOfRangeException">
|
|
/// <paramref name="index" /> or <paramref name="count" /> is less than zero.-or- <paramref name="index" /> and <paramref name="count" /> do not denote a valid range in <paramref name="chars" />.-or- The resulting number of bytes is greater than the maximum number that can be returned as an integer. </exception>
|
|
/// <exception cref="T:System.ArgumentException">Error detection is enabled, and <paramref name="chars" /> contains an invalid sequence of characters. </exception>
|
|
/// <exception cref="T:System.Text.EncoderFallbackException">A fallback occurred (see Understanding Encodings for complete explanation)-and-<see cref="P:System.Text.Encoding.EncoderFallback" /> is set to <see cref="T:System.Text.EncoderExceptionFallback" />.</exception>
|
|
/// <filterpriority>1</filterpriority>
|
|
// Token: 0x06003840 RID: 14400 RVA: 0x000C1C00 File Offset: 0x000BFE00
|
|
public override int GetByteCount(char[] chars, int index, int count)
|
|
{
|
|
char c = '\0';
|
|
return UTF8Encoding.InternalGetByteCount(chars, index, count, ref c, true);
|
|
}
|
|
|
|
/// <summary>Calculates the number of bytes produced by encoding a set of characters starting at the specified character pointer.</summary>
|
|
/// <returns>The number of bytes produced by encoding the specified characters.</returns>
|
|
/// <param name="chars">A pointer to the first character to encode. </param>
|
|
/// <param name="count">The number of characters to encode. </param>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="chars" /> is null. </exception>
|
|
/// <exception cref="T:System.ArgumentOutOfRangeException">
|
|
/// <paramref name="count" /> is less than zero.-or- The resulting number of bytes is greater than the maximum number that can be returned as an integer. </exception>
|
|
/// <exception cref="T:System.ArgumentException">Error detection is enabled, and <paramref name="chars" /> contains an invalid sequence of characters. </exception>
|
|
/// <exception cref="T:System.Text.EncoderFallbackException">A fallback occurred (see Understanding Encodings for complete explanation)-and-<see cref="P:System.Text.Encoding.EncoderFallback" /> is set to <see cref="T:System.Text.EncoderExceptionFallback" />.</exception>
|
|
/// <filterpriority>1</filterpriority>
|
|
// Token: 0x06003841 RID: 14401 RVA: 0x000C1C1C File Offset: 0x000BFE1C
|
|
[CLSCompliant(false)]
|
|
[ComVisible(false)]
|
|
public unsafe override int GetByteCount(char* chars, int count)
|
|
{
|
|
if (chars == null)
|
|
{
|
|
throw new ArgumentNullException("chars");
|
|
}
|
|
if (count == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
char c = '\0';
|
|
return UTF8Encoding.InternalGetByteCount(chars, count, ref c, true);
|
|
}
|
|
|
|
// Token: 0x06003842 RID: 14402 RVA: 0x000C1C50 File Offset: 0x000BFE50
|
|
private unsafe static int InternalGetBytes(char[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex, ref char leftOver, bool flush)
|
|
{
|
|
if (chars == null)
|
|
{
|
|
throw new ArgumentNullException("chars");
|
|
}
|
|
if (bytes == null)
|
|
{
|
|
throw new ArgumentNullException("bytes");
|
|
}
|
|
if (charIndex < 0 || charIndex > chars.Length)
|
|
{
|
|
throw new ArgumentOutOfRangeException("charIndex", Encoding._("ArgRange_Array"));
|
|
}
|
|
if (charCount < 0 || charCount > chars.Length - charIndex)
|
|
{
|
|
throw new ArgumentOutOfRangeException("charCount", Encoding._("ArgRange_Array"));
|
|
}
|
|
if (byteIndex < 0 || byteIndex > bytes.Length)
|
|
{
|
|
throw new ArgumentOutOfRangeException("byteIndex", Encoding._("ArgRange_Array"));
|
|
}
|
|
if (charIndex == chars.Length)
|
|
{
|
|
if (flush && leftOver != '\0')
|
|
{
|
|
leftOver = '\0';
|
|
}
|
|
return 0;
|
|
}
|
|
fixed (char* ptr = (ref chars != null && chars.Length != 0 ? ref chars[0] : ref *null))
|
|
{
|
|
if (bytes.Length == byteIndex)
|
|
{
|
|
return UTF8Encoding.InternalGetBytes(ptr + charIndex, charCount, null, 0, ref leftOver, flush);
|
|
}
|
|
fixed (byte* ptr2 = (ref bytes != null && bytes.Length != 0 ? ref bytes[0] : ref *null))
|
|
{
|
|
return UTF8Encoding.InternalGetBytes(ptr + charIndex, charCount, ptr2 + byteIndex, bytes.Length - byteIndex, ref leftOver, flush);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x06003843 RID: 14403 RVA: 0x000C1D80 File Offset: 0x000BFF80
|
|
private unsafe static int InternalGetBytes(char* chars, int count, byte* bytes, int bcount, ref char leftOver, bool flush)
|
|
{
|
|
char* ptr = chars + count;
|
|
byte* ptr2 = bytes + bcount;
|
|
while (chars < ptr)
|
|
{
|
|
if (leftOver == '\0')
|
|
{
|
|
while (chars < ptr)
|
|
{
|
|
int num = (int)(*chars);
|
|
if (num < 128)
|
|
{
|
|
if (bytes >= ptr2)
|
|
{
|
|
goto IL_29B;
|
|
}
|
|
*(bytes++) = (byte)num;
|
|
}
|
|
else if (num < 2048)
|
|
{
|
|
if (bytes + 1 >= ptr2)
|
|
{
|
|
goto IL_29B;
|
|
}
|
|
*bytes = (byte)(192 | (num >> 6));
|
|
bytes[1] = (byte)(128 | (num & 63));
|
|
bytes += 2;
|
|
}
|
|
else if (num < 55296 || num > 57343)
|
|
{
|
|
if (bytes + 2 >= ptr2)
|
|
{
|
|
goto IL_29B;
|
|
}
|
|
*bytes = (byte)(224 | (num >> 12));
|
|
bytes[1] = (byte)(128 | ((num >> 6) & 63));
|
|
bytes[2] = (byte)(128 | (num & 63));
|
|
bytes += 3;
|
|
}
|
|
else
|
|
{
|
|
if (num <= 56319)
|
|
{
|
|
leftOver = *chars;
|
|
chars++;
|
|
break;
|
|
}
|
|
if (bytes + 2 >= ptr2)
|
|
{
|
|
goto IL_29B;
|
|
}
|
|
*bytes = (byte)(224 | (num >> 12));
|
|
bytes[1] = (byte)(128 | ((num >> 6) & 63));
|
|
bytes[2] = (byte)(128 | (num & 63));
|
|
bytes += 3;
|
|
leftOver = '\0';
|
|
}
|
|
chars++;
|
|
}
|
|
continue;
|
|
}
|
|
if (*chars >= '\udc00' && *chars <= '\udfff')
|
|
{
|
|
int num2 = 65536 + (int)(*chars) - 56320 + (int)((int)(leftOver - '\ud800') << 10);
|
|
if (bytes + 3 >= ptr2)
|
|
{
|
|
goto IL_29B;
|
|
}
|
|
*bytes = (byte)(240 | (num2 >> 18));
|
|
bytes[1] = (byte)(128 | ((num2 >> 12) & 63));
|
|
bytes[2] = (byte)(128 | ((num2 >> 6) & 63));
|
|
bytes[3] = (byte)(128 | (num2 & 63));
|
|
bytes += 4;
|
|
chars++;
|
|
}
|
|
else
|
|
{
|
|
int num3 = (int)leftOver;
|
|
if (bytes + 2 >= ptr2)
|
|
{
|
|
goto IL_29B;
|
|
}
|
|
*bytes = (byte)(224 | (num3 >> 12));
|
|
bytes[1] = (byte)(128 | ((num3 >> 6) & 63));
|
|
bytes[2] = (byte)(128 | (num3 & 63));
|
|
bytes += 3;
|
|
}
|
|
leftOver = '\0';
|
|
continue;
|
|
IL_29B:
|
|
throw new ArgumentException("Insufficient Space", "bytes");
|
|
}
|
|
if (flush && leftOver != '\0')
|
|
{
|
|
int num4 = (int)leftOver;
|
|
if (bytes + 2 >= ptr2)
|
|
{
|
|
goto IL_29B;
|
|
}
|
|
*bytes = (byte)(224 | (num4 >> 12));
|
|
bytes[1] = (byte)(128 | ((num4 >> 6) & 63));
|
|
bytes[2] = (byte)(128 | (num4 & 63));
|
|
bytes += 3;
|
|
leftOver = '\0';
|
|
}
|
|
return (int)((long)(bytes - (ptr2 - bcount)));
|
|
}
|
|
|
|
/// <summary>Encodes a set of characters from the specified character array into the specified byte array.</summary>
|
|
/// <returns>The actual number of bytes written into <paramref name="bytes" />.</returns>
|
|
/// <param name="chars">The character array containing the set of characters to encode. </param>
|
|
/// <param name="charIndex">The index of the first character to encode. </param>
|
|
/// <param name="charCount">The number of characters to encode. </param>
|
|
/// <param name="bytes">The byte array to contain the resulting sequence of bytes. </param>
|
|
/// <param name="byteIndex">The index at which to start writing the resulting sequence of bytes. </param>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="chars" /> is null.-or- <paramref name="bytes" /> is null. </exception>
|
|
/// <exception cref="T:System.ArgumentOutOfRangeException">
|
|
/// <paramref name="charIndex" /> or <paramref name="charCount" /> or <paramref name="byteIndex" /> is less than zero.-or- <paramref name="charIndex" /> and <paramref name="charCount" /> do not denote a valid range in <paramref name="chars" />.-or- <paramref name="byteIndex" /> is not a valid index in <paramref name="bytes" />. </exception>
|
|
/// <exception cref="T:System.ArgumentException">Error detection is enabled, and <paramref name="chars" /> contains an invalid sequence of characters.-or- <paramref name="bytes" /> does not have enough capacity from <paramref name="byteIndex" /> to the end of the array to accommodate the resulting bytes. </exception>
|
|
/// <exception cref="T:System.Text.EncoderFallbackException">A fallback occurred (see Understanding Encodings for complete explanation)-and-<see cref="P:System.Text.Encoding.EncoderFallback" /> is set to <see cref="T:System.Text.EncoderExceptionFallback" />.</exception>
|
|
/// <filterpriority>1</filterpriority>
|
|
// Token: 0x06003844 RID: 14404 RVA: 0x000C2038 File Offset: 0x000C0238
|
|
public override int GetBytes(char[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex)
|
|
{
|
|
char c = '\0';
|
|
return UTF8Encoding.InternalGetBytes(chars, charIndex, charCount, bytes, byteIndex, ref c, true);
|
|
}
|
|
|
|
/// <summary>Encodes a set of characters from the specified <see cref="T:System.String" /> into the specified byte array.</summary>
|
|
/// <returns>The actual number of bytes written into <paramref name="bytes" />.</returns>
|
|
/// <param name="s">The <see cref="T:System.String" /> containing the set of characters to encode. </param>
|
|
/// <param name="charIndex">The index of the first character to encode. </param>
|
|
/// <param name="charCount">The number of characters to encode. </param>
|
|
/// <param name="bytes">The byte array to contain the resulting sequence of bytes. </param>
|
|
/// <param name="byteIndex">The index at which to start writing the resulting sequence of bytes. </param>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="s" /> is null.-or- <paramref name="bytes" /> is null. </exception>
|
|
/// <exception cref="T:System.ArgumentOutOfRangeException">
|
|
/// <paramref name="charIndex" /> or <paramref name="charCount" /> or <paramref name="byteIndex" /> is less than zero.-or- <paramref name="charIndex" /> and <paramref name="charCount" /> do not denote a valid range in <paramref name="chars" />.-or- <paramref name="byteIndex" /> is not a valid index in <paramref name="bytes" />. </exception>
|
|
/// <exception cref="T:System.ArgumentException">Error detection is enabled, and <paramref name="s" /> contains an invalid sequence of characters.-or- <paramref name="bytes" /> does not have enough capacity from <paramref name="byteIndex" /> to the end of the array to accommodate the resulting bytes. </exception>
|
|
/// <exception cref="T:System.Text.EncoderFallbackException">A fallback occurred (see Understanding Encodings for complete explanation)-and-<see cref="P:System.Text.Encoding.EncoderFallback" /> is set to <see cref="T:System.Text.EncoderExceptionFallback" />.</exception>
|
|
/// <filterpriority>1</filterpriority>
|
|
// Token: 0x06003845 RID: 14405 RVA: 0x000C2058 File Offset: 0x000C0258
|
|
public unsafe override int GetBytes(string s, int charIndex, int charCount, byte[] bytes, int byteIndex)
|
|
{
|
|
if (s == null)
|
|
{
|
|
throw new ArgumentNullException("s");
|
|
}
|
|
if (bytes == null)
|
|
{
|
|
throw new ArgumentNullException("bytes");
|
|
}
|
|
if (charIndex < 0 || charIndex > s.Length)
|
|
{
|
|
throw new ArgumentOutOfRangeException("charIndex", Encoding._("ArgRange_StringIndex"));
|
|
}
|
|
if (charCount < 0 || charCount > s.Length - charIndex)
|
|
{
|
|
throw new ArgumentOutOfRangeException("charCount", Encoding._("ArgRange_StringRange"));
|
|
}
|
|
if (byteIndex < 0 || byteIndex > bytes.Length)
|
|
{
|
|
throw new ArgumentOutOfRangeException("byteIndex", Encoding._("ArgRange_Array"));
|
|
}
|
|
if (charIndex == s.Length)
|
|
{
|
|
return 0;
|
|
}
|
|
fixed (char* ptr = s + RuntimeHelpers.OffsetToStringData / 2)
|
|
{
|
|
char c = '\0';
|
|
if (bytes.Length == byteIndex)
|
|
{
|
|
return UTF8Encoding.InternalGetBytes(ptr + charIndex, charCount, null, 0, ref c, true);
|
|
}
|
|
fixed (byte* ptr2 = (ref bytes != null && bytes.Length != 0 ? ref bytes[0] : ref *null))
|
|
{
|
|
return UTF8Encoding.InternalGetBytes(ptr + charIndex, charCount, ptr2 + byteIndex, bytes.Length - byteIndex, ref c, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>Encodes a set of characters starting at the specified character pointer into a sequence of bytes that are stored starting at the specified byte pointer.</summary>
|
|
/// <returns>The actual number of bytes written at the location indicated by <paramref name="bytes" />.</returns>
|
|
/// <param name="chars">A pointer to the first character to encode. </param>
|
|
/// <param name="charCount">The number of characters to encode. </param>
|
|
/// <param name="bytes">A pointer to the location at which to start writing the resulting sequence of bytes. </param>
|
|
/// <param name="byteCount">The maximum number of bytes to write. </param>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="chars" /> is null.-or- <paramref name="bytes" /> is null. </exception>
|
|
/// <exception cref="T:System.ArgumentOutOfRangeException">
|
|
/// <paramref name="charCount" /> or <paramref name="byteCount" /> is less than zero. </exception>
|
|
/// <exception cref="T:System.ArgumentException">Error detection is enabled, and <paramref name="chars" /> contains an invalid sequence of characters.-or- <paramref name="byteCount" /> is less than the resulting number of bytes. </exception>
|
|
/// <exception cref="T:System.Text.EncoderFallbackException">A fallback occurred (see Understanding Encodings for complete explanation)-and-<see cref="P:System.Text.Encoding.EncoderFallback" /> is set to <see cref="T:System.Text.EncoderExceptionFallback" />.</exception>
|
|
/// <filterpriority>1</filterpriority>
|
|
// Token: 0x06003846 RID: 14406 RVA: 0x000C2174 File Offset: 0x000C0374
|
|
[CLSCompliant(false)]
|
|
[ComVisible(false)]
|
|
public unsafe override int GetBytes(char* chars, int charCount, byte* bytes, int byteCount)
|
|
{
|
|
if (chars == null)
|
|
{
|
|
throw new ArgumentNullException("chars");
|
|
}
|
|
if (charCount < 0)
|
|
{
|
|
throw new IndexOutOfRangeException("charCount");
|
|
}
|
|
if (bytes == null)
|
|
{
|
|
throw new ArgumentNullException("bytes");
|
|
}
|
|
if (byteCount < 0)
|
|
{
|
|
throw new IndexOutOfRangeException("charCount");
|
|
}
|
|
if (charCount == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
char c = '\0';
|
|
if (byteCount == 0)
|
|
{
|
|
return UTF8Encoding.InternalGetBytes(chars, charCount, null, 0, ref c, true);
|
|
}
|
|
return UTF8Encoding.InternalGetBytes(chars, charCount, bytes, byteCount, ref c, true);
|
|
}
|
|
|
|
// Token: 0x06003847 RID: 14407 RVA: 0x000C21F4 File Offset: 0x000C03F4
|
|
private unsafe static int InternalGetCharCount(byte[] bytes, int index, int count, uint leftOverBits, uint leftOverCount, object provider, ref DecoderFallbackBuffer fallbackBuffer, ref byte[] bufferArg, bool flush)
|
|
{
|
|
if (bytes == null)
|
|
{
|
|
throw new ArgumentNullException("bytes");
|
|
}
|
|
if (index < 0 || index > bytes.Length)
|
|
{
|
|
throw new ArgumentOutOfRangeException("index", Encoding._("ArgRange_Array"));
|
|
}
|
|
if (count < 0 || count > bytes.Length - index)
|
|
{
|
|
throw new ArgumentOutOfRangeException("count", Encoding._("ArgRange_Array"));
|
|
}
|
|
if (count == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
fixed (byte* ptr = (ref bytes != null && bytes.Length != 0 ? ref bytes[0] : ref *null))
|
|
{
|
|
return UTF8Encoding.InternalGetCharCount(ptr + index, count, leftOverBits, leftOverCount, provider, ref fallbackBuffer, ref bufferArg, flush);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06003848 RID: 14408 RVA: 0x000C2298 File Offset: 0x000C0498
|
|
private unsafe static int InternalGetCharCount(byte* bytes, int count, uint leftOverBits, uint leftOverCount, object provider, ref DecoderFallbackBuffer fallbackBuffer, ref byte[] bufferArg, bool flush)
|
|
{
|
|
int i = 0;
|
|
int num = 0;
|
|
if (leftOverCount == 0U)
|
|
{
|
|
int num2 = i + count;
|
|
while (i < num2)
|
|
{
|
|
if (bytes[i] >= 128)
|
|
{
|
|
break;
|
|
}
|
|
num++;
|
|
i++;
|
|
count--;
|
|
}
|
|
}
|
|
uint num3 = leftOverBits;
|
|
uint num4 = leftOverCount & 15U;
|
|
uint num5 = (leftOverCount >> 4) & 15U;
|
|
while (count > 0)
|
|
{
|
|
uint num6 = (uint)bytes[i++];
|
|
count--;
|
|
if (num5 == 0U)
|
|
{
|
|
if (num6 < 128U)
|
|
{
|
|
num++;
|
|
}
|
|
else if ((num6 & 224U) == 192U)
|
|
{
|
|
num3 = num6 & 31U;
|
|
num4 = 1U;
|
|
num5 = 2U;
|
|
}
|
|
else if ((num6 & 240U) == 224U)
|
|
{
|
|
num3 = num6 & 15U;
|
|
num4 = 1U;
|
|
num5 = 3U;
|
|
}
|
|
else if ((num6 & 248U) == 240U)
|
|
{
|
|
num3 = num6 & 7U;
|
|
num4 = 1U;
|
|
num5 = 4U;
|
|
}
|
|
else if ((num6 & 252U) == 248U)
|
|
{
|
|
num3 = num6 & 3U;
|
|
num4 = 1U;
|
|
num5 = 5U;
|
|
}
|
|
else if ((num6 & 254U) == 252U)
|
|
{
|
|
num3 = num6 & 3U;
|
|
num4 = 1U;
|
|
num5 = 6U;
|
|
}
|
|
else
|
|
{
|
|
num += UTF8Encoding.Fallback(provider, ref fallbackBuffer, ref bufferArg, bytes, (long)(i - 1), 1U);
|
|
}
|
|
}
|
|
else if ((num6 & 192U) == 128U)
|
|
{
|
|
num3 = (num3 << 6) | (num6 & 63U);
|
|
if ((num4 += 1U) >= num5)
|
|
{
|
|
if (num3 < 65536U)
|
|
{
|
|
bool flag = false;
|
|
switch (num5)
|
|
{
|
|
case 2U:
|
|
flag = num3 <= 127U;
|
|
break;
|
|
case 3U:
|
|
flag = num3 <= 2047U;
|
|
break;
|
|
case 4U:
|
|
flag = num3 <= 65535U;
|
|
break;
|
|
case 5U:
|
|
flag = num3 <= 2097151U;
|
|
break;
|
|
case 6U:
|
|
flag = num3 <= 67108863U;
|
|
break;
|
|
}
|
|
if (flag)
|
|
{
|
|
num += UTF8Encoding.Fallback(provider, ref fallbackBuffer, ref bufferArg, bytes, (long)i - (long)((ulong)num4), num4);
|
|
}
|
|
else if ((num3 & 63488U) == 55296U)
|
|
{
|
|
num += UTF8Encoding.Fallback(provider, ref fallbackBuffer, ref bufferArg, bytes, (long)i - (long)((ulong)num4), num4);
|
|
}
|
|
else
|
|
{
|
|
num++;
|
|
}
|
|
}
|
|
else if (num3 < 1114112U)
|
|
{
|
|
num += 2;
|
|
}
|
|
else
|
|
{
|
|
num += UTF8Encoding.Fallback(provider, ref fallbackBuffer, ref bufferArg, bytes, (long)i - (long)((ulong)num4), num4);
|
|
}
|
|
num5 = 0U;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
num += UTF8Encoding.Fallback(provider, ref fallbackBuffer, ref bufferArg, bytes, (long)i - (long)((ulong)num4), num4);
|
|
num5 = 0U;
|
|
i--;
|
|
count++;
|
|
}
|
|
}
|
|
if (flush && num5 != 0U)
|
|
{
|
|
num += UTF8Encoding.Fallback(provider, ref fallbackBuffer, ref bufferArg, bytes, (long)i - (long)((ulong)num4), num4);
|
|
}
|
|
return num;
|
|
}
|
|
|
|
// Token: 0x06003849 RID: 14409 RVA: 0x000C257C File Offset: 0x000C077C
|
|
private unsafe static int Fallback(object provider, ref DecoderFallbackBuffer buffer, ref byte[] bufferArg, byte* bytes, long index, uint size)
|
|
{
|
|
if (buffer == null)
|
|
{
|
|
DecoderFallback decoderFallback = provider as DecoderFallback;
|
|
if (decoderFallback != null)
|
|
{
|
|
buffer = decoderFallback.CreateFallbackBuffer();
|
|
}
|
|
else
|
|
{
|
|
buffer = ((Decoder)provider).FallbackBuffer;
|
|
}
|
|
}
|
|
if (bufferArg == null)
|
|
{
|
|
bufferArg = new byte[1];
|
|
}
|
|
int num = 0;
|
|
int num2 = 0;
|
|
while ((long)num2 < (long)((ulong)size))
|
|
{
|
|
bufferArg[0] = bytes[(int)index + num2];
|
|
buffer.Fallback(bufferArg, 0);
|
|
num += buffer.Remaining;
|
|
buffer.Reset();
|
|
num2++;
|
|
}
|
|
return num;
|
|
}
|
|
|
|
// Token: 0x0600384A RID: 14410 RVA: 0x000C2608 File Offset: 0x000C0808
|
|
private unsafe static void Fallback(object provider, ref DecoderFallbackBuffer buffer, ref byte[] bufferArg, byte* bytes, long byteIndex, uint size, char* chars, ref int charIndex)
|
|
{
|
|
if (buffer == null)
|
|
{
|
|
DecoderFallback decoderFallback = provider as DecoderFallback;
|
|
if (decoderFallback != null)
|
|
{
|
|
buffer = decoderFallback.CreateFallbackBuffer();
|
|
}
|
|
else
|
|
{
|
|
buffer = ((Decoder)provider).FallbackBuffer;
|
|
}
|
|
}
|
|
if (bufferArg == null)
|
|
{
|
|
bufferArg = new byte[1];
|
|
}
|
|
int num = 0;
|
|
while ((long)num < (long)((ulong)size))
|
|
{
|
|
bufferArg[0] = bytes[byteIndex + (long)num];
|
|
buffer.Fallback(bufferArg, 0);
|
|
while (buffer.Remaining > 0)
|
|
{
|
|
chars[charIndex++] = buffer.GetNextChar();
|
|
}
|
|
buffer.Reset();
|
|
num++;
|
|
}
|
|
}
|
|
|
|
/// <summary>Calculates the number of characters produced by decoding a sequence of bytes from the specified byte array.</summary>
|
|
/// <returns>The number of characters produced by decoding the specified sequence of bytes.</returns>
|
|
/// <param name="bytes">The byte array containing the sequence of bytes to decode. </param>
|
|
/// <param name="index">The index of the first byte to decode. </param>
|
|
/// <param name="count">The number of bytes to decode. </param>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="bytes" /> is null. </exception>
|
|
/// <exception cref="T:System.ArgumentOutOfRangeException">
|
|
/// <paramref name="index" /> or <paramref name="count" /> is less than zero.-or- <paramref name="index" /> and <paramref name="count" /> do not denote a valid range in <paramref name="bytes" />.-or- The resulting number of bytes is greater than the maximum number that can be returned as an integer. </exception>
|
|
/// <exception cref="T:System.ArgumentException">Error detection is enabled, and <paramref name="bytes" /> contains an invalid sequence of bytes. </exception>
|
|
/// <exception cref="T:System.Text.DecoderFallbackException">A fallback occurred (see Understanding Encodings for complete explanation)-and-<see cref="P:System.Text.Encoding.DecoderFallback" /> is set to <see cref="T:System.Text.DecoderExceptionFallback" />.</exception>
|
|
/// <filterpriority>1</filterpriority>
|
|
// Token: 0x0600384B RID: 14411 RVA: 0x000C26B0 File Offset: 0x000C08B0
|
|
public override int GetCharCount(byte[] bytes, int index, int count)
|
|
{
|
|
DecoderFallbackBuffer decoderFallbackBuffer = null;
|
|
byte[] array = null;
|
|
return UTF8Encoding.InternalGetCharCount(bytes, index, count, 0U, 0U, base.DecoderFallback, ref decoderFallbackBuffer, ref array, true);
|
|
}
|
|
|
|
/// <summary>Calculates the number of characters produced by decoding a sequence of bytes starting at the specified byte pointer.</summary>
|
|
/// <returns>The number of characters produced by decoding the specified sequence of bytes.</returns>
|
|
/// <param name="bytes"></param>
|
|
/// <param name="count"></param>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="bytes" /> is null. </exception>
|
|
/// <exception cref="T:System.ArgumentOutOfRangeException">
|
|
/// <paramref name="count" /> is less than zero.-or- The resulting number of bytes is greater than the maximum number that can be returned as an integer. </exception>
|
|
/// <exception cref="T:System.ArgumentException">Error detection is enabled, and <paramref name="bytes" /> contains an invalid sequence of bytes. </exception>
|
|
/// <exception cref="T:System.Text.DecoderFallbackException">A fallback occurred (see Understanding Encodings for complete explanation)-and-<see cref="P:System.Text.Encoding.DecoderFallback" /> is set to <see cref="T:System.Text.DecoderExceptionFallback" />.</exception>
|
|
/// <filterpriority>1</filterpriority>
|
|
// Token: 0x0600384C RID: 14412 RVA: 0x000C26D8 File Offset: 0x000C08D8
|
|
[CLSCompliant(false)]
|
|
[ComVisible(false)]
|
|
public unsafe override int GetCharCount(byte* bytes, int count)
|
|
{
|
|
DecoderFallbackBuffer decoderFallbackBuffer = null;
|
|
byte[] array = null;
|
|
return UTF8Encoding.InternalGetCharCount(bytes, count, 0U, 0U, base.DecoderFallback, ref decoderFallbackBuffer, ref array, true);
|
|
}
|
|
|
|
// Token: 0x0600384D RID: 14413 RVA: 0x000C2700 File Offset: 0x000C0900
|
|
private unsafe static int InternalGetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex, ref uint leftOverBits, ref uint leftOverCount, object provider, ref DecoderFallbackBuffer fallbackBuffer, ref byte[] bufferArg, bool flush)
|
|
{
|
|
if (bytes == null)
|
|
{
|
|
throw new ArgumentNullException("bytes");
|
|
}
|
|
if (chars == null)
|
|
{
|
|
throw new ArgumentNullException("chars");
|
|
}
|
|
if (byteIndex < 0 || byteIndex > bytes.Length)
|
|
{
|
|
throw new ArgumentOutOfRangeException("byteIndex", Encoding._("ArgRange_Array"));
|
|
}
|
|
if (byteCount < 0 || byteCount > bytes.Length - byteIndex)
|
|
{
|
|
throw new ArgumentOutOfRangeException("byteCount", Encoding._("ArgRange_Array"));
|
|
}
|
|
if (charIndex < 0 || charIndex > chars.Length)
|
|
{
|
|
throw new ArgumentOutOfRangeException("charIndex", Encoding._("ArgRange_Array"));
|
|
}
|
|
if (charIndex == chars.Length)
|
|
{
|
|
return 0;
|
|
}
|
|
fixed (char* ptr = (ref chars != null && chars.Length != 0 ? ref chars[0] : ref *null))
|
|
{
|
|
if (byteCount == 0 || byteIndex == bytes.Length)
|
|
{
|
|
return UTF8Encoding.InternalGetChars(null, 0, ptr + charIndex, chars.Length - charIndex, ref leftOverBits, ref leftOverCount, provider, ref fallbackBuffer, ref bufferArg, flush);
|
|
}
|
|
fixed (byte* ptr2 = (ref bytes != null && bytes.Length != 0 ? ref bytes[0] : ref *null))
|
|
{
|
|
return UTF8Encoding.InternalGetChars(ptr2 + byteIndex, byteCount, ptr + charIndex, chars.Length - charIndex, ref leftOverBits, ref leftOverCount, provider, ref fallbackBuffer, ref bufferArg, flush);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600384E RID: 14414 RVA: 0x000C283C File Offset: 0x000C0A3C
|
|
private unsafe static int InternalGetChars(byte* bytes, int byteCount, char* chars, int charCount, ref uint leftOverBits, ref uint leftOverCount, object provider, ref DecoderFallbackBuffer fallbackBuffer, ref byte[] bufferArg, bool flush)
|
|
{
|
|
int num = 0;
|
|
int i = 0;
|
|
int num2 = num;
|
|
if (leftOverCount == 0U)
|
|
{
|
|
int num3 = i + byteCount;
|
|
while (i < num3)
|
|
{
|
|
if (bytes[i] >= 128)
|
|
{
|
|
break;
|
|
}
|
|
chars[num2] = (char)bytes[i];
|
|
num2++;
|
|
i++;
|
|
byteCount--;
|
|
}
|
|
}
|
|
uint num4 = leftOverBits;
|
|
uint num5 = leftOverCount & 15U;
|
|
uint num6 = (leftOverCount >> 4) & 15U;
|
|
int num7 = i + byteCount;
|
|
while (i < num7)
|
|
{
|
|
uint num8 = (uint)bytes[i];
|
|
if (num6 == 0U)
|
|
{
|
|
if (num8 < 128U)
|
|
{
|
|
if (num2 >= charCount)
|
|
{
|
|
throw new ArgumentException(Encoding._("Arg_InsufficientSpace"), "chars");
|
|
}
|
|
chars[num2++] = (char)num8;
|
|
}
|
|
else if ((num8 & 224U) == 192U)
|
|
{
|
|
num4 = num8 & 31U;
|
|
num5 = 1U;
|
|
num6 = 2U;
|
|
}
|
|
else if ((num8 & 240U) == 224U)
|
|
{
|
|
num4 = num8 & 15U;
|
|
num5 = 1U;
|
|
num6 = 3U;
|
|
}
|
|
else if ((num8 & 248U) == 240U)
|
|
{
|
|
num4 = num8 & 7U;
|
|
num5 = 1U;
|
|
num6 = 4U;
|
|
}
|
|
else if ((num8 & 252U) == 248U)
|
|
{
|
|
num4 = num8 & 3U;
|
|
num5 = 1U;
|
|
num6 = 5U;
|
|
}
|
|
else if ((num8 & 254U) == 252U)
|
|
{
|
|
num4 = num8 & 3U;
|
|
num5 = 1U;
|
|
num6 = 6U;
|
|
}
|
|
else
|
|
{
|
|
UTF8Encoding.Fallback(provider, ref fallbackBuffer, ref bufferArg, bytes, (long)i, 1U, chars, ref num2);
|
|
}
|
|
}
|
|
else if ((num8 & 192U) == 128U)
|
|
{
|
|
num4 = (num4 << 6) | (num8 & 63U);
|
|
if ((num5 += 1U) >= num6)
|
|
{
|
|
if (num4 < 65536U)
|
|
{
|
|
bool flag = false;
|
|
switch (num6)
|
|
{
|
|
case 2U:
|
|
flag = num4 <= 127U;
|
|
break;
|
|
case 3U:
|
|
flag = num4 <= 2047U;
|
|
break;
|
|
case 4U:
|
|
flag = num4 <= 65535U;
|
|
break;
|
|
case 5U:
|
|
flag = num4 <= 2097151U;
|
|
break;
|
|
case 6U:
|
|
flag = num4 <= 67108863U;
|
|
break;
|
|
}
|
|
if (flag)
|
|
{
|
|
UTF8Encoding.Fallback(provider, ref fallbackBuffer, ref bufferArg, bytes, (long)i - (long)((ulong)num5), num5, chars, ref num2);
|
|
}
|
|
else if ((num4 & 63488U) == 55296U)
|
|
{
|
|
UTF8Encoding.Fallback(provider, ref fallbackBuffer, ref bufferArg, bytes, (long)i - (long)((ulong)num5), num5, chars, ref num2);
|
|
}
|
|
else
|
|
{
|
|
if (num2 >= charCount)
|
|
{
|
|
throw new ArgumentException(Encoding._("Arg_InsufficientSpace"), "chars");
|
|
}
|
|
chars[num2++] = (char)num4;
|
|
}
|
|
}
|
|
else if (num4 < 1114112U)
|
|
{
|
|
if (num2 + 2 > charCount)
|
|
{
|
|
throw new ArgumentException(Encoding._("Arg_InsufficientSpace"), "chars");
|
|
}
|
|
num4 -= 65536U;
|
|
chars[num2++] = (char)((num4 >> 10) + 55296U);
|
|
chars[num2++] = (char)((num4 & 1023U) + 56320U);
|
|
}
|
|
else
|
|
{
|
|
UTF8Encoding.Fallback(provider, ref fallbackBuffer, ref bufferArg, bytes, (long)i - (long)((ulong)num5), num5, chars, ref num2);
|
|
}
|
|
num6 = 0U;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
UTF8Encoding.Fallback(provider, ref fallbackBuffer, ref bufferArg, bytes, (long)i - (long)((ulong)num5), num5, chars, ref num2);
|
|
num6 = 0U;
|
|
i--;
|
|
}
|
|
i++;
|
|
}
|
|
if (flush && num6 != 0U)
|
|
{
|
|
UTF8Encoding.Fallback(provider, ref fallbackBuffer, ref bufferArg, bytes, (long)i - (long)((ulong)num5), num5, chars, ref num2);
|
|
}
|
|
leftOverBits = num4;
|
|
leftOverCount = num5 | (num6 << 4);
|
|
return num2 - num;
|
|
}
|
|
|
|
/// <summary>Decodes a sequence of bytes from the specified byte array into the specified character array.</summary>
|
|
/// <returns>The actual number of characters written into <paramref name="chars" />.</returns>
|
|
/// <param name="bytes">The byte array containing the sequence of bytes to decode. </param>
|
|
/// <param name="byteIndex">The index of the first byte to decode. </param>
|
|
/// <param name="byteCount">The number of bytes to decode. </param>
|
|
/// <param name="chars">The character array to contain the resulting set of characters. </param>
|
|
/// <param name="charIndex">The index at which to start writing the resulting set of characters. </param>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="bytes" /> is null.-or- <paramref name="chars" /> is null. </exception>
|
|
/// <exception cref="T:System.ArgumentOutOfRangeException">
|
|
/// <paramref name="byteIndex" /> or <paramref name="byteCount" /> or <paramref name="charIndex" /> is less than zero.-or- <paramref name="byteindex" /> and <paramref name="byteCount" /> do not denote a valid range in <paramref name="bytes" />.-or- <paramref name="charIndex" /> is not a valid index in <paramref name="chars" />. </exception>
|
|
/// <exception cref="T:System.ArgumentException">Error detection is enabled, and <paramref name="bytes" /> contains an invalid sequence of bytes.-or- <paramref name="chars" /> does not have enough capacity from <paramref name="charIndex" /> to the end of the array to accommodate the resulting characters. </exception>
|
|
/// <exception cref="T:System.Text.DecoderFallbackException">A fallback occurred (see Understanding Encodings for complete explanation)-and-<see cref="P:System.Text.Encoding.DecoderFallback" /> is set to <see cref="T:System.Text.DecoderExceptionFallback" />.</exception>
|
|
/// <filterpriority>1</filterpriority>
|
|
// Token: 0x0600384F RID: 14415 RVA: 0x000C2BF0 File Offset: 0x000C0DF0
|
|
public override int GetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex)
|
|
{
|
|
uint num = 0U;
|
|
uint num2 = 0U;
|
|
DecoderFallbackBuffer decoderFallbackBuffer = null;
|
|
byte[] array = null;
|
|
return UTF8Encoding.InternalGetChars(bytes, byteIndex, byteCount, chars, charIndex, ref num, ref num2, base.DecoderFallback, ref decoderFallbackBuffer, ref array, true);
|
|
}
|
|
|
|
/// <summary>Decodes a sequence of bytes starting at the specified byte pointer into a set of characters that are stored starting at the specified character pointer.</summary>
|
|
/// <returns>The actual number of characters written at the location indicated by <paramref name="chars" />.</returns>
|
|
/// <param name="bytes">A pointer to the first byte to decode. </param>
|
|
/// <param name="byteCount">The number of bytes to decode. </param>
|
|
/// <param name="chars">A pointer to the location at which to start writing the resulting set of characters. </param>
|
|
/// <param name="charCount">The maximum number of characters to write. </param>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="bytes" /> is null.-or- <paramref name="chars" /> is null. </exception>
|
|
/// <exception cref="T:System.ArgumentOutOfRangeException">
|
|
/// <paramref name="byteCount" /> or <paramref name="charCount" /> is less than zero. </exception>
|
|
/// <exception cref="T:System.ArgumentException">Error detection is enabled, and <paramref name="bytes" /> contains an invalid sequence of bytes.-or- <paramref name="charCount" /> is less than the resulting number of characters. </exception>
|
|
/// <exception cref="T:System.Text.DecoderFallbackException">A fallback occurred (see Understanding Encodings for complete explanation)-and-<see cref="P:System.Text.Encoding.DecoderFallback" /> is set to <see cref="T:System.Text.DecoderExceptionFallback" />.</exception>
|
|
/// <filterpriority>1</filterpriority>
|
|
// Token: 0x06003850 RID: 14416 RVA: 0x000C2C20 File Offset: 0x000C0E20
|
|
[ComVisible(false)]
|
|
[CLSCompliant(false)]
|
|
public unsafe override int GetChars(byte* bytes, int byteCount, char* chars, int charCount)
|
|
{
|
|
DecoderFallbackBuffer decoderFallbackBuffer = null;
|
|
byte[] array = null;
|
|
uint num = 0U;
|
|
uint num2 = 0U;
|
|
return UTF8Encoding.InternalGetChars(bytes, byteCount, chars, charCount, ref num, ref num2, base.DecoderFallback, ref decoderFallbackBuffer, ref array, true);
|
|
}
|
|
|
|
/// <summary>Calculates the maximum number of bytes produced by encoding the specified number of characters.</summary>
|
|
/// <returns>The maximum number of bytes produced by encoding the specified number of characters.</returns>
|
|
/// <param name="charCount">The number of characters to encode. </param>
|
|
/// <exception cref="T:System.ArgumentOutOfRangeException">
|
|
/// <paramref name="charCount" /> is less than zero.-or- The resulting number of bytes is greater than the maximum number that can be returned as an integer. </exception>
|
|
/// <exception cref="T:System.Text.EncoderFallbackException">A fallback occurred (see Understanding Encodings for complete explanation)-and-<see cref="P:System.Text.Encoding.EncoderFallback" /> is set to <see cref="T:System.Text.EncoderExceptionFallback" />.</exception>
|
|
/// <filterpriority>1</filterpriority>
|
|
// Token: 0x06003851 RID: 14417 RVA: 0x000C2C50 File Offset: 0x000C0E50
|
|
public override int GetMaxByteCount(int charCount)
|
|
{
|
|
if (charCount < 0)
|
|
{
|
|
throw new ArgumentOutOfRangeException("charCount", Encoding._("ArgRange_NonNegative"));
|
|
}
|
|
return charCount * 4;
|
|
}
|
|
|
|
/// <summary>Calculates the maximum number of characters produced by decoding the specified number of bytes.</summary>
|
|
/// <returns>The maximum number of characters produced by decoding the specified number of bytes.</returns>
|
|
/// <param name="byteCount">The number of bytes to decode. </param>
|
|
/// <exception cref="T:System.ArgumentOutOfRangeException">
|
|
/// <paramref name="byteCount" /> is less than zero.-or- The resulting number of bytes is greater than the maximum number that can be returned as an integer. </exception>
|
|
/// <exception cref="T:System.Text.DecoderFallbackException">A fallback occurred (see Understanding Encodings for complete explanation)-and-<see cref="P:System.Text.Encoding.DecoderFallback" /> is set to <see cref="T:System.Text.DecoderExceptionFallback" />.</exception>
|
|
/// <filterpriority>1</filterpriority>
|
|
// Token: 0x06003852 RID: 14418 RVA: 0x000C2C74 File Offset: 0x000C0E74
|
|
public override int GetMaxCharCount(int byteCount)
|
|
{
|
|
if (byteCount < 0)
|
|
{
|
|
throw new ArgumentOutOfRangeException("byteCount", Encoding._("ArgRange_NonNegative"));
|
|
}
|
|
return byteCount;
|
|
}
|
|
|
|
/// <summary>Obtains a decoder that converts a UTF-8 encoded sequence of bytes into a sequence of Unicode characters.</summary>
|
|
/// <returns>A <see cref="T:System.Text.Decoder" /> that converts a UTF-8 encoded sequence of bytes into a sequence of Unicode characters.</returns>
|
|
/// <filterpriority>1</filterpriority>
|
|
// Token: 0x06003853 RID: 14419 RVA: 0x000C2C94 File Offset: 0x000C0E94
|
|
public override Decoder GetDecoder()
|
|
{
|
|
return new UTF8Encoding.UTF8Decoder(base.DecoderFallback);
|
|
}
|
|
|
|
/// <summary>Obtains an encoder that converts a sequence of Unicode characters into a UTF-8 encoded sequence of bytes.</summary>
|
|
/// <returns>A <see cref="T:System.Text.Encoder" /> that converts a sequence of Unicode characters into a UTF-8 encoded sequence of bytes.</returns>
|
|
/// <filterpriority>1</filterpriority>
|
|
// Token: 0x06003854 RID: 14420 RVA: 0x000C2CA4 File Offset: 0x000C0EA4
|
|
public override Encoder GetEncoder()
|
|
{
|
|
return new UTF8Encoding.UTF8Encoder(this.emitIdentifier);
|
|
}
|
|
|
|
/// <summary>Returns a Unicode byte order mark encoded in UTF-8 format, if the constructor for this instance requests a byte order mark.</summary>
|
|
/// <returns>A byte array containing the Unicode byte order mark, if the constructor for this instance requests a byte order mark. Otherwise, this method returns a byte array of length zero.</returns>
|
|
/// <filterpriority>1</filterpriority>
|
|
// Token: 0x06003855 RID: 14421 RVA: 0x000C2CB4 File Offset: 0x000C0EB4
|
|
public override byte[] GetPreamble()
|
|
{
|
|
if (this.emitIdentifier)
|
|
{
|
|
return new byte[] { 239, 187, 191 };
|
|
}
|
|
return new byte[0];
|
|
}
|
|
|
|
/// <summary>Determines whether the specified <see cref="T:System.Object" /> is equal to the current <see cref="T:System.Text.UTF8Encoding" /> object.</summary>
|
|
/// <returns>true if <paramref name="value" /> is an instance of <see cref="T:System.Text.UTF8Encoding" /> and is equal to the current object; otherwise, false.</returns>
|
|
/// <param name="value">The <see cref="T:System.Object" /> to compare with the current instance. </param>
|
|
/// <filterpriority>2</filterpriority>
|
|
// Token: 0x06003856 RID: 14422 RVA: 0x000C2CF4 File Offset: 0x000C0EF4
|
|
public override bool Equals(object value)
|
|
{
|
|
UTF8Encoding utf8Encoding = value as UTF8Encoding;
|
|
return utf8Encoding != null && (this.codePage == utf8Encoding.codePage && this.emitIdentifier == utf8Encoding.emitIdentifier && base.DecoderFallback.Equals(utf8Encoding.DecoderFallback)) && base.EncoderFallback.Equals(utf8Encoding.EncoderFallback);
|
|
}
|
|
|
|
/// <summary>Returns the hash code for the current instance.</summary>
|
|
/// <returns>The hash code for the current instance.</returns>
|
|
/// <filterpriority>1</filterpriority>
|
|
// Token: 0x06003857 RID: 14423 RVA: 0x000C2D5C File Offset: 0x000C0F5C
|
|
public override int GetHashCode()
|
|
{
|
|
return base.GetHashCode();
|
|
}
|
|
|
|
/// <summary>Calculates the number of bytes produced by encoding the characters in the specified <see cref="T:System.String" />.</summary>
|
|
/// <returns>The number of bytes produced by encoding the specified characters.</returns>
|
|
/// <param name="chars">The <see cref="T:System.String" /> containing the set of characters to encode. </param>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="chars" /> is null. </exception>
|
|
/// <exception cref="T:System.ArgumentOutOfRangeException">The resulting number of bytes is greater than the maximum number that can be returned as an integer. </exception>
|
|
/// <exception cref="T:System.ArgumentException">Error detection is enabled, and <paramref name="chars" /> contains an invalid sequence of characters. </exception>
|
|
/// <exception cref="T:System.Text.EncoderFallbackException">A fallback occurred (see Understanding Encodings for complete explanation)-and-<see cref="P:System.Text.Encoding.EncoderFallback" /> is set to <see cref="T:System.Text.EncoderExceptionFallback" />.</exception>
|
|
/// <filterpriority>1</filterpriority>
|
|
// Token: 0x06003858 RID: 14424 RVA: 0x000C2D64 File Offset: 0x000C0F64
|
|
public override int GetByteCount(string chars)
|
|
{
|
|
return base.GetByteCount(chars);
|
|
}
|
|
|
|
/// <summary>Decodes a range of bytes from a byte array into a string.</summary>
|
|
/// <returns>A <see cref="T:System.String" /> containing the results of decoding the specified sequence of bytes.</returns>
|
|
/// <param name="bytes">The byte array containing the sequence of bytes to decode. </param>
|
|
/// <param name="index">The index of the first byte to decode. </param>
|
|
/// <param name="count">The number of bytes to decode. </param>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="bytes" /> is null. </exception>
|
|
/// <exception cref="T:System.ArgumentOutOfRangeException">
|
|
/// <paramref name="index" /> or <paramref name="count" /> is less than zero.-or- <paramref name="index" /> and <paramref name="count" /> do not denote a valid range in <paramref name="bytes" />. </exception>
|
|
/// <exception cref="T:System.ArgumentException">Error detection is enabled, and <paramref name="bytes" /> contains an invalid sequence of bytes. </exception>
|
|
/// <exception cref="T:System.Text.DecoderFallbackException">A fallback occurred (see Understanding Encodings for complete explanation)-and-<see cref="P:System.Text.Encoding.DecoderFallback" /> is set to <see cref="T:System.Text.DecoderExceptionFallback" />.</exception>
|
|
/// <filterpriority>1</filterpriority>
|
|
// Token: 0x06003859 RID: 14425 RVA: 0x000C2D70 File Offset: 0x000C0F70
|
|
[ComVisible(false)]
|
|
public override string GetString(byte[] bytes, int index, int count)
|
|
{
|
|
return base.GetString(bytes, index, count);
|
|
}
|
|
|
|
// Token: 0x040016CB RID: 5835
|
|
internal const int UTF8_CODE_PAGE = 65001;
|
|
|
|
// Token: 0x040016CC RID: 5836
|
|
private bool emitIdentifier;
|
|
|
|
// Token: 0x02000602 RID: 1538
|
|
[Serializable]
|
|
private class UTF8Decoder : Decoder
|
|
{
|
|
// Token: 0x0600385A RID: 14426 RVA: 0x000C2D7C File Offset: 0x000C0F7C
|
|
public UTF8Decoder(DecoderFallback fallback)
|
|
{
|
|
base.Fallback = fallback;
|
|
this.leftOverBits = 0U;
|
|
this.leftOverCount = 0U;
|
|
}
|
|
|
|
// Token: 0x0600385B RID: 14427 RVA: 0x000C2D9C File Offset: 0x000C0F9C
|
|
public override int GetCharCount(byte[] bytes, int index, int count)
|
|
{
|
|
DecoderFallbackBuffer decoderFallbackBuffer = null;
|
|
byte[] array = null;
|
|
return UTF8Encoding.InternalGetCharCount(bytes, index, count, this.leftOverBits, this.leftOverCount, this, ref decoderFallbackBuffer, ref array, false);
|
|
}
|
|
|
|
// Token: 0x0600385C RID: 14428 RVA: 0x000C2DC8 File Offset: 0x000C0FC8
|
|
public override int GetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex)
|
|
{
|
|
DecoderFallbackBuffer decoderFallbackBuffer = null;
|
|
byte[] array = null;
|
|
return UTF8Encoding.InternalGetChars(bytes, byteIndex, byteCount, chars, charIndex, ref this.leftOverBits, ref this.leftOverCount, this, ref decoderFallbackBuffer, ref array, false);
|
|
}
|
|
|
|
// Token: 0x040016CD RID: 5837
|
|
private uint leftOverBits;
|
|
|
|
// Token: 0x040016CE RID: 5838
|
|
private uint leftOverCount;
|
|
}
|
|
|
|
// Token: 0x02000603 RID: 1539
|
|
[Serializable]
|
|
private class UTF8Encoder : Encoder
|
|
{
|
|
// Token: 0x0600385D RID: 14429 RVA: 0x000C2DF8 File Offset: 0x000C0FF8
|
|
public UTF8Encoder(bool emitIdentifier)
|
|
{
|
|
this.leftOverForCount = '\0';
|
|
this.leftOverForConv = '\0';
|
|
}
|
|
|
|
// Token: 0x0600385E RID: 14430 RVA: 0x000C2E10 File Offset: 0x000C1010
|
|
public override int GetByteCount(char[] chars, int index, int count, bool flush)
|
|
{
|
|
return UTF8Encoding.InternalGetByteCount(chars, index, count, ref this.leftOverForCount, flush);
|
|
}
|
|
|
|
// Token: 0x0600385F RID: 14431 RVA: 0x000C2E24 File Offset: 0x000C1024
|
|
public override int GetBytes(char[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex, bool flush)
|
|
{
|
|
return UTF8Encoding.InternalGetBytes(chars, charIndex, charCount, bytes, byteIndex, ref this.leftOverForConv, flush);
|
|
}
|
|
|
|
// Token: 0x06003860 RID: 14432 RVA: 0x000C2E48 File Offset: 0x000C1048
|
|
public unsafe override int GetByteCount(char* chars, int count, bool flush)
|
|
{
|
|
return UTF8Encoding.InternalGetByteCount(chars, count, ref this.leftOverForCount, flush);
|
|
}
|
|
|
|
// Token: 0x06003861 RID: 14433 RVA: 0x000C2E58 File Offset: 0x000C1058
|
|
public unsafe override int GetBytes(char* chars, int charCount, byte* bytes, int byteCount, bool flush)
|
|
{
|
|
return UTF8Encoding.InternalGetBytes(chars, charCount, bytes, byteCount, ref this.leftOverForConv, flush);
|
|
}
|
|
|
|
// Token: 0x040016CF RID: 5839
|
|
private char leftOverForCount;
|
|
|
|
// Token: 0x040016D0 RID: 5840
|
|
private char leftOverForConv;
|
|
}
|
|
}
|
|
}
|