* UTF8Encoding.cs - Implementation of the "System.Text.UTF8Encoding" class.
*
* Copyright (c) 2001, 2002 Southern Storm Software, Pty Ltd
+ * Copyright (C) 2004 Novell, Inc (http://www.novell.com)
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the "Software"),
using System;
[Serializable]
+[MonoTODO ("Fix serialization compatibility with MS.NET")]
+#if NET_2_0
+[MonoTODO ("EncoderFallback is not handled")]
+#endif
public class UTF8Encoding : Encoding
{
// Magic number used by Windows for UTF-8.
// Internal state.
private bool emitIdentifier;
+#if !NET_2_0
private bool throwOnInvalid;
+#endif
// Constructors.
- public UTF8Encoding()
- : this(false, false) {}
- public UTF8Encoding(bool encoderShouldEmitUTF8Identifier)
- : this(encoderShouldEmitUTF8Identifier, false) {}
- public UTF8Encoding(bool encoderShouldEmitUTF8Identifier,
- bool throwOnInvalidBytes)
- : base(UTF8_CODE_PAGE)
- {
- emitIdentifier = encoderShouldEmitUTF8Identifier;
- throwOnInvalid = throwOnInvalidBytes;
- }
+ public UTF8Encoding () : this (false, false) {}
+ public UTF8Encoding (bool encoderShouldEmitUTF8Identifier)
+ : this (encoderShouldEmitUTF8Identifier, false) {}
+
+ public UTF8Encoding (bool encoderShouldEmitUTF8Identifier, bool throwOnInvalidBytes)
+ : base (UTF8_CODE_PAGE)
+ {
+ emitIdentifier = encoderShouldEmitUTF8Identifier;
+#if NET_2_0
+ if (throwOnInvalidBytes)
+ SetFallbackInternal (null, new DecoderExceptionFallback ());
+ else
+ SetFallbackInternal (null, new DecoderReplacementFallback (String.Empty));
+#else
+ throwOnInvalid = throwOnInvalidBytes;
+#endif
+
+ web_name = body_name = header_name = "utf-8";
+ encoding_name = "Unicode (UTF-8)";
+ is_browser_save = true;
+ is_browser_display = true;
+ is_mail_news_display = true;
+ windows_code_page = UnicodeEncoding.UNICODE_CODE_PAGE;
+ }
// Internal version of "GetByteCount" which can handle a rolling
// state between multiple calls to this method.
- private static int InternalGetByteCount(char[] chars, int index,
- int count, uint leftOver,
- bool emitIdentifier, bool flush)
- {
- // Validate the parameters.
- if(chars == null)
- {
- throw new ArgumentNullException("chars");
- }
- if(index < 0 || index > chars.Length)
- {
- throw new ArgumentOutOfRangeException
- ("index", _("ArgRange_Array"));
- }
- if(count < 0 || count > (chars.Length - index))
- {
- throw new ArgumentOutOfRangeException
- ("count", _("ArgRange_Array"));
- }
-
- // Determine the lengths of all characters.
- char ch;
- int length = 0;
- uint pair = leftOver;
- while(count > 0)
- {
- ch = chars[index];
- if(pair == 0)
- {
- if(ch < '\u0080')
- {
- ++length;
- }
- else if(ch < '\u0800')
- {
- length += 2;
- }
- else if(ch >= '\uD800' && ch <= '\uDBFF')
- {
- // This is the start of a surrogate pair.
- pair = (uint)ch;
- }
- else
- {
- length += 3;
- }
- }
- else if(ch >= '\uDC00' && ch <= '\uDFFF')
- {
- // We have a surrogate pair.
- length += 4;
- pair = 0;
- }
- else
- {
- // We have a surrogate start followed by a
- // regular character. Technically, this is
- // invalid, but we have to do something.
- // We write out the surrogate start and then
- // re-visit the current character again.
- length += 3;
- pair = 0;
- continue;
- }
- ++index;
- --count;
- }
- if(flush && pair != 0)
- {
- // Flush the left-over surrogate pair start.
+ private static int InternalGetByteCount (char[] chars, int index, int count, uint leftOver, bool flush)
+ {
+ // Validate the parameters.
+ if (chars == null) {
+ throw new ArgumentNullException ("chars");
+ }
+ if (index < 0 || index > chars.Length) {
+ throw new ArgumentOutOfRangeException ("index", _("ArgRange_Array"));
+ }
+ if (count < 0 || count > (chars.Length - index)) {
+ throw new ArgumentOutOfRangeException ("count", _("ArgRange_Array"));
+ }
+
+ // Determine the lengths of all characters.
+ char ch;
+ int length = 0;
+ uint pair = leftOver;
+ while (count > 0) {
+ ch = chars[index];
+ if (pair == 0) {
+ if (ch < '\u0080') {
+ ++length;
+ } else if (ch < '\u0800') {
+ length += 2;
+ } else if (ch >= '\uD800' && ch <= '\uDBFF') {
+ // This is the start of a surrogate pair.
+ pair = (uint)ch;
+ } else {
length += 3;
}
-
- // Return the final length to the caller.
- return length + (emitIdentifier ? 3 : 0);
+ } else if (ch >= '\uDC00' && ch <= '\uDFFF') {
+ // We have a surrogate pair.
+ length += 4;
+ pair = 0;
+ } else {
+ // We have a surrogate start followed by a
+ // regular character. Technically, this is
+ // invalid, but we have to do something.
+ // We write out the surrogate start and then
+ // re-visit the current character again.
+ length += 3;
+ pair = 0;
+ continue;
}
+ ++index;
+ --count;
+ }
+ if (flush && pair != 0) {
+ // Flush the left-over surrogate pair start.
+ length += 3;
+ }
+
+ // Return the final length to the caller.
+ return length;
+ }
// Get the number of bytes needed to encode a character buffer.
- public override int GetByteCount(char[] chars, int index, int count)
- {
- return InternalGetByteCount(chars, index, count, 0,
- emitIdentifier, true);
- }
+ public override int GetByteCount (char[] chars, int index, int count)
+ {
+ return InternalGetByteCount (chars, index, count, 0, true);
+ }
// Convenience wrappers for "GetByteCount".
- public override int GetByteCount(String s)
- {
- // Validate the parameters.
- if(s == null)
- {
- throw new ArgumentNullException("s");
- }
-
- // Determine the lengths of all characters.
- char ch;
- int index = 0;
- int count = s.Length;
- int length = 0;
- uint pair;
- while(count > 0)
- {
- ch = s[index++];
- if(ch < '\u0080')
- {
- ++length;
- }
- else if(ch < '\u0800')
- {
- length += 2;
- }
- else if(ch >= '\uD800' && ch <= '\uDBFF' && count > 1)
- {
- // This may be the start of a surrogate pair.
- pair = (uint)(s[index]);
- if(pair >= (uint)0xDC00 && pair <= (uint)0xDFFF)
- {
- length += 4;
- ++index;
- --count;
- }
- else
- {
- length += 3;
- }
- }
- else
- {
- length += 3;
- }
+ public override int GetByteCount (String s)
+ {
+ // Validate the parameters.
+ if (s == null) {
+ throw new ArgumentNullException ("s");
+ }
+
+ // Determine the lengths of all characters.
+ char ch;
+ int index = 0;
+ int count = s.Length;
+ int length = 0;
+ uint pair;
+ while (count > 0) {
+ ch = s[index++];
+ if (ch < '\u0080') {
+ ++length;
+ } else if (ch < '\u0800') {
+ length += 2;
+ } else if (ch >= '\uD800' && ch <= '\uDBFF' && count > 1) {
+ // This may be the start of a surrogate pair.
+ pair = (uint)(s[index]);
+ if (pair >= (uint)0xDC00 && pair <= (uint)0xDFFF) {
+ length += 4;
+ ++index;
--count;
+ } else {
+ length += 3;
}
-
- // Return the final length to the caller.
- return length + (emitIdentifier ? 3 : 0);
+ } else {
+ length += 3;
}
+ --count;
+ }
+
+ // Return the final length to the caller.
+ return length;
+ }
// Internal version of "GetBytes" which can handle a rolling
// state between multiple calls to this method.
- private static int InternalGetBytes(char[] chars, int charIndex,
- int charCount, byte[] bytes,
- int byteIndex, ref uint leftOver,
- bool emitIdentifier, bool flush)
- {
- // Validate the parameters.
- if(chars == null)
- {
- throw new ArgumentNullException("chars");
- }
- if(bytes == null)
- {
- throw new ArgumentNullException("bytes");
- }
- if(charIndex < 0 || charIndex > chars.Length)
- {
- throw new ArgumentOutOfRangeException
- ("charIndex", _("ArgRange_Array"));
- }
- if(charCount < 0 || charCount > (chars.Length - charIndex))
- {
- throw new ArgumentOutOfRangeException
- ("charCount", _("ArgRange_Array"));
- }
- if(byteIndex < 0 || byteIndex > bytes.Length)
- {
- throw new ArgumentOutOfRangeException
- ("byteIndex", _("ArgRange_Array"));
- }
-
- // Convert the characters into bytes.
- char ch;
- int length = bytes.Length;
- uint pair;
- uint left = leftOver;
- int posn = byteIndex;
- if(emitIdentifier)
- {
- if((posn + 3) > length)
- {
- throw new ArgumentException
- (_("Arg_InsufficientSpace"), "bytes");
- }
- bytes[posn++] = (byte)0xEF;
- bytes[posn++] = (byte)0xBB;
- bytes[posn++] = (byte)0xBF;
- }
- while(charCount > 0)
- {
- // Fetch the next UTF-16 character pair value.
- ch = chars[charIndex++];
- --charCount;
- if(left == 0)
- {
- if(ch >= '\uD800' && ch <= '\uDBFF')
- {
- // This is the start of a surrogate pair.
- left = (uint)ch;
- continue;
- }
- else
- {
- // This is a regular character.
- pair = (uint)ch;
- }
- }
- else if(ch >= '\uDC00' && ch <= '\uDFFF')
- {
- // We have a surrogate pair.
- pair = ((left - (uint)0xD800) << 10) +
- (((uint)ch) - (uint)0xDC00) +
- (uint)0x10000;
- left = 0;
- }
- else
- {
- // We have a surrogate start followed by a
- // regular character. Technically, this is
- // invalid, but we have to do something.
- // We write out the surrogate start and then
- // re-visit the current character again.
- pair = (uint)left;
- left = 0;
- --charIndex;
- ++charCount;
- }
-
- // Encode the character pair value.
- if(pair < (uint)0x0080)
- {
- if(posn >= length)
- {
- throw new ArgumentException
- (_("Arg_InsufficientSpace"), "bytes");
- }
- bytes[posn++] = (byte)pair;
- }
- else if(pair < (uint)0x0800)
- {
- if((posn + 2) > length)
- {
- throw new ArgumentException
- (_("Arg_InsufficientSpace"), "bytes");
- }
- bytes[posn++] = (byte)(0xC0 | (pair >> 6));
- bytes[posn++] = (byte)(0x80 | (pair & 0x3F));
- }
- else if(pair < (uint)0x10000)
- {
- if((posn + 3) > length)
- {
- throw new ArgumentException
- (_("Arg_InsufficientSpace"), "bytes");
- }
- bytes[posn++] = (byte)(0xE0 | (pair >> 12));
- bytes[posn++] = (byte)(0x80 | ((pair >> 6) & 0x3F));
- bytes[posn++] = (byte)(0x80 | (pair & 0x3F));
- }
- else
- {
- if((posn + 4) > length)
- {
- throw new ArgumentException
- (_("Arg_InsufficientSpace"), "bytes");
- }
- bytes[posn++] = (byte)(0xF0 | (pair >> 18));
- bytes[posn++] = (byte)(0x80 | ((pair >> 12) & 0x3F));
- bytes[posn++] = (byte)(0x80 | ((pair >> 6) & 0x3F));
- bytes[posn++] = (byte)(0x80 | (pair & 0x3F));
- }
- }
- if(flush && left != 0)
- {
- // Flush the left-over surrogate pair start.
- if((posn + 3) > length)
- {
- throw new ArgumentException
- (_("Arg_InsufficientSpace"), "bytes");
- }
- bytes[posn++] = (byte)(0xE0 | (left >> 12));
- bytes[posn++] = (byte)(0x80 | ((left >> 6) & 0x3F));
- bytes[posn++] = (byte)(0x80 | (left & 0x3F));
- left = 0;
- }
- leftOver = left;
+ private static int InternalGetBytes (char[] chars, int charIndex,
+ int charCount, byte[] bytes,
+ int byteIndex, ref uint leftOver,
+ bool flush)
+ {
+ // Validate the parameters.
+ if (chars == null) {
+ throw new ArgumentNullException ("chars");
+ }
+ if (bytes == null) {
+ throw new ArgumentNullException ("bytes");
+ }
+ if (charIndex < 0 || charIndex > chars.Length) {
+ throw new ArgumentOutOfRangeException ("charIndex", _("ArgRange_Array"));
+ }
+ if (charCount < 0 || charCount > (chars.Length - charIndex)) {
+ throw new ArgumentOutOfRangeException ("charCount", _("ArgRange_Array"));
+ }
+ if (byteIndex < 0 || byteIndex > bytes.Length) {
+ throw new ArgumentOutOfRangeException ("byteIndex", _("ArgRange_Array"));
+ }
+
+ // Convert the characters into bytes.
+ char ch;
+ int length = bytes.Length;
+ uint pair;
+ uint left = leftOver;
+ int posn = byteIndex;
+ while (charCount > 0) {
+ // Fetch the next UTF-16 character pair value.
+ ch = chars[charIndex++];
+ --charCount;
+ if (left == 0) {
+ if (ch >= '\uD800' && ch <= '\uDBFF') {
+ // This is the start of a surrogate pair.
+ left = (uint)ch;
+ continue;
+ } else {
+ // This is a regular character.
+ pair = (uint)ch;
+ }
+ } else if (ch >= '\uDC00' && ch <= '\uDFFF') {
+ // We have a surrogate pair.
+ pair = ((left - (uint)0xD800) << 10) +
+ (((uint)ch) - (uint)0xDC00) +
+ (uint)0x10000;
+ left = 0;
+ } else {
+ // We have a surrogate start followed by a
+ // regular character. Technically, this is
+ // invalid, but we have to do something.
+ // We write out the surrogate start and then
+ // re-visit the current character again.
+ pair = (uint)left;
+ left = 0;
+ --charIndex;
+ ++charCount;
+ }
- // Return the final count to the caller.
- return posn - byteIndex;
+ // Encode the character pair value.
+ if (pair < (uint)0x0080) {
+ if (posn >= length) {
+ throw new ArgumentException (_("Arg_InsufficientSpace"), "bytes");
+ }
+ bytes[posn++] = (byte)pair;
+ } else if (pair < (uint)0x0800) {
+ if ((posn + 2) > length) {
+ throw new ArgumentException (_("Arg_InsufficientSpace"), "bytes");
+ }
+ bytes[posn++] = (byte)(0xC0 | (pair >> 6));
+ bytes[posn++] = (byte)(0x80 | (pair & 0x3F));
+ } else if (pair < (uint)0x10000) {
+ if ((posn + 3) > length) {
+ throw new ArgumentException (_("Arg_InsufficientSpace"), "bytes");
+ }
+ bytes[posn++] = (byte)(0xE0 | (pair >> 12));
+ bytes[posn++] = (byte)(0x80 | ((pair >> 6) & 0x3F));
+ bytes[posn++] = (byte)(0x80 | (pair & 0x3F));
+ } else {
+ if ((posn + 4) > length) {
+ throw new ArgumentException (_("Arg_InsufficientSpace"), "bytes");
+ }
+ bytes[posn++] = (byte)(0xF0 | (pair >> 18));
+ bytes[posn++] = (byte)(0x80 | ((pair >> 12) & 0x3F));
+ bytes[posn++] = (byte)(0x80 | ((pair >> 6) & 0x3F));
+ bytes[posn++] = (byte)(0x80 | (pair & 0x3F));
}
+ }
+ if (flush && left != 0) {
+ // Flush the left-over surrogate pair start.
+ if ((posn + 3) > length) {
+ throw new ArgumentException (_("Arg_InsufficientSpace"), "bytes");
+ }
+ bytes[posn++] = (byte)(0xE0 | (left >> 12));
+ bytes[posn++] = (byte)(0x80 | ((left >> 6) & 0x3F));
+ bytes[posn++] = (byte)(0x80 | (left & 0x3F));
+ left = 0;
+ }
+ leftOver = left;
+
+ // Return the final count to the caller.
+ return posn - byteIndex;
+ }
// Get the bytes that result from encoding a character buffer.
- public override int GetBytes(char[] chars, int charIndex, int charCount,
+ public override int GetBytes (char[] chars, int charIndex, int charCount,
byte[] bytes, int byteIndex)
- {
- uint leftOver = 0;
- return InternalGetBytes(chars, charIndex, charCount,
- bytes, byteIndex, ref leftOver,
- emitIdentifier, true);
- }
+ {
+ uint leftOver = 0;
+ return InternalGetBytes (chars, charIndex, charCount, bytes, byteIndex, ref leftOver, true);
+ }
// Convenience wrappers for "GetBytes".
- public override int GetBytes(String s, int charIndex, int charCount,
+ public override int GetBytes (String s, int charIndex, int charCount,
byte[] bytes, int byteIndex)
- {
- // Validate the parameters.
- if(s == null)
- {
- throw new ArgumentNullException("s");
- }
- if(bytes == null)
- {
- throw new ArgumentNullException("bytes");
- }
- if(charIndex < 0 || charIndex > s.Length)
- {
- throw new ArgumentOutOfRangeException
- ("charIndex", _("ArgRange_StringIndex"));
- }
- if(charCount < 0 || charCount > (s.Length - charIndex))
- {
- throw new ArgumentOutOfRangeException
- ("charCount", _("ArgRange_StringRange"));
- }
- if(byteIndex < 0 || byteIndex > bytes.Length)
- {
- throw new ArgumentOutOfRangeException
- ("byteIndex", _("ArgRange_Array"));
- }
-
- // Convert the characters into bytes.
- char ch;
- int length = bytes.Length;
- uint pair;
- int posn = byteIndex;
- if(emitIdentifier)
- {
- if((posn + 3) > length)
- {
- throw new ArgumentException
- (_("Arg_InsufficientSpace"), "bytes");
- }
- bytes[posn++] = (byte)0xEF;
- bytes[posn++] = (byte)0xBB;
- bytes[posn++] = (byte)0xBF;
- }
- while(charCount > 0)
- {
- // Fetch the next UTF-16 character pair value.
- ch = s[charIndex++];
+ {
+ // Validate the parameters.
+ if (s == null) {
+ throw new ArgumentNullException ("s");
+ }
+ if (bytes == null) {
+ throw new ArgumentNullException ("bytes");
+ }
+ if (charIndex < 0 || charIndex > s.Length) {
+ throw new ArgumentOutOfRangeException ("charIndex", _("ArgRange_StringIndex"));
+ }
+ if (charCount < 0 || charCount > (s.Length - charIndex)) {
+ throw new ArgumentOutOfRangeException ("charCount", _("ArgRange_StringRange"));
+ }
+ if (byteIndex < 0 || byteIndex > bytes.Length) {
+ throw new ArgumentOutOfRangeException ("byteIndex", _("ArgRange_Array"));
+ }
+
+ // Convert the characters into bytes.
+ char ch;
+ int length = bytes.Length;
+ uint pair;
+ int posn = byteIndex;
+ while (charCount > 0) {
+ // Fetch the next UTF-16 character pair value.
+ ch = s[charIndex++];
+ if (ch >= '\uD800' && ch <= '\uDBFF' && charCount > 1) {
+ // This may be the start of a surrogate pair.
+ pair = (uint)(s[charIndex]);
+ if (pair >= (uint)0xDC00 && pair <= (uint)0xDFFF) {
+ pair = (pair - (uint)0xDC00) +
+ ((((uint)ch) - (uint)0xD800) << 10) +
+ (uint)0x10000;
+ ++charIndex;
--charCount;
- if(ch >= '\uD800' && ch <= '\uDBFF' && charCount > 1)
- {
- // This may be the start of a surrogate pair.
- pair = (uint)(s[charIndex]);
- if(pair >= (uint)0xDC00 && pair <= (uint)0xDFFF)
- {
- pair = (pair - (uint)0xDC00) +
- ((((uint)ch) - (uint)0xD800) << 10) +
- (uint)0x10000;
- ++charIndex;
- --charCount;
- }
- else
- {
- pair = (uint)ch;
- }
- }
- else
- {
- pair = (uint)ch;
- }
-
- // Encode the character pair value.
- if(pair < (uint)0x0080)
- {
- if(posn >= length)
- {
- throw new ArgumentException
- (_("Arg_InsufficientSpace"), "bytes");
- }
- bytes[posn++] = (byte)pair;
- }
- else if(pair < (uint)0x0800)
- {
- if((posn + 2) > length)
- {
- throw new ArgumentException
- (_("Arg_InsufficientSpace"), "bytes");
- }
- bytes[posn++] = (byte)(0xC0 | (pair >> 6));
- bytes[posn++] = (byte)(0x80 | (pair & 0x3F));
- }
- else if(pair < (uint)0x10000)
- {
- if((posn + 3) > length)
- {
- throw new ArgumentException
- (_("Arg_InsufficientSpace"), "bytes");
- }
- bytes[posn++] = (byte)(0xE0 | (pair >> 12));
- bytes[posn++] = (byte)(0x80 | ((pair >> 6) & 0x3F));
- bytes[posn++] = (byte)(0x80 | (pair & 0x3F));
- }
- else
- {
- if((posn + 4) > length)
- {
- throw new ArgumentException
- (_("Arg_InsufficientSpace"), "bytes");
- }
- bytes[posn++] = (byte)(0xF0 | (pair >> 18));
- bytes[posn++] = (byte)(0x80 | ((pair >> 12) & 0x3F));
- bytes[posn++] = (byte)(0x80 | ((pair >> 6) & 0x3F));
- bytes[posn++] = (byte)(0x80 | (pair & 0x3F));
- }
+ } else {
+ pair = (uint)ch;
}
-
- // Return the final count to the caller.
- return posn - byteIndex;
+ } else {
+ pair = (uint)ch;
+ }
+ --charCount;
+
+ // Encode the character pair value.
+ if (pair < (uint)0x0080) {
+ if (posn >= length) {
+ throw new ArgumentException (_("Arg_InsufficientSpace"), "bytes");
+ }
+ bytes[posn++] = (byte)pair;
+ } else if (pair < (uint)0x0800) {
+ if ((posn + 2) > length) {
+ throw new ArgumentException (_("Arg_InsufficientSpace"), "bytes");
+ }
+ bytes[posn++] = (byte)(0xC0 | (pair >> 6));
+ bytes[posn++] = (byte)(0x80 | (pair & 0x3F));
+ } else if (pair < (uint)0x10000) {
+ if ((posn + 3) > length) {
+ throw new ArgumentException (_("Arg_InsufficientSpace"), "bytes");
+ }
+ bytes[posn++] = (byte)(0xE0 | (pair >> 12));
+ bytes[posn++] = (byte)(0x80 | ((pair >> 6) & 0x3F));
+ bytes[posn++] = (byte)(0x80 | (pair & 0x3F));
+ } else {
+ if ((posn + 4) > length) {
+ throw new ArgumentException (_("Arg_InsufficientSpace"), "bytes");
+ }
+ bytes[posn++] = (byte)(0xF0 | (pair >> 18));
+ bytes[posn++] = (byte)(0x80 | ((pair >> 12) & 0x3F));
+ bytes[posn++] = (byte)(0x80 | ((pair >> 6) & 0x3F));
+ bytes[posn++] = (byte)(0x80 | (pair & 0x3F));
}
+ }
+
+ // Return the final count to the caller.
+ return posn - byteIndex;
+ }
// Internal version of "GetCharCount" which can handle a rolling
// state between multiple calls to this method.
- private static int InternalGetCharCount(byte[] bytes, int index, int count,
- uint leftOverBits,
- uint leftOverCount,
- bool throwOnInvalid, bool flush)
- {
- // Validate the parameters.
- if(bytes == null)
- {
- throw new ArgumentNullException("bytes");
- }
- if(index < 0 || index > bytes.Length)
- {
- throw new ArgumentOutOfRangeException
- ("index", _("ArgRange_Array"));
- }
- if(count < 0 || count > (bytes.Length - index))
- {
- throw new ArgumentOutOfRangeException
- ("count", _("ArgRange_Array"));
- }
-
- // Determine the number of characters that we have.
- uint ch;
- int length = 0;
- uint leftBits = leftOverBits;
- uint leftSoFar = (leftOverCount & (uint)0x0F);
- uint leftSize = ((leftOverCount >> 4) & (uint)0x0F);
- while(count > 0)
- {
- ch = (uint)(bytes[index++]);
- --count;
- if(leftSize == 0)
- {
- // Process a UTF-8 start character.
- if(ch < (uint)0x0080)
- {
- // Single-byte UTF-8 character.
- ++length;
- }
- else if((ch & (uint)0xE0) == (uint)0xC0)
- {
- // Double-byte UTF-8 character.
- leftBits = (ch & (uint)0x1F);
- leftSoFar = 1;
- leftSize = 2;
- }
- else if((ch & (uint)0xF0) == (uint)0xE0)
- {
- // Three-byte UTF-8 character.
- leftBits = (ch & (uint)0x0F);
- leftSoFar = 1;
- leftSize = 3;
- }
- else if((ch & (uint)0xF8) == (uint)0xF0)
- {
- // Four-byte UTF-8 character.
- leftBits = (ch & (uint)0x07);
- leftSoFar = 1;
- leftSize = 4;
- }
- else if((ch & (uint)0xFC) == (uint)0xF8)
- {
- // Five-byte UTF-8 character.
- leftBits = (ch & (uint)0x03);
- leftSoFar = 1;
- leftSize = 5;
- }
- else if((ch & (uint)0xFC) == (uint)0xFC)
- {
- // Six-byte UTF-8 character.
- leftBits = (ch & (uint)0x03);
- leftSoFar = 1;
- leftSize = 6;
- }
- else
- {
- // Invalid UTF-8 start character.
- if(throwOnInvalid)
- {
- throw new ArgumentException
- (_("Arg_InvalidUTF8"), "bytes");
- }
- }
- }
- else
- {
- // Process an extra byte in a multi-byte sequence.
- if((ch & (uint)0xC0) == (uint)0x80)
- {
- leftBits = ((leftBits << 6) | (ch & (uint)0x3F));
- if(++leftSoFar >= leftSize)
- {
- // We have a complete character now.
- if(leftBits < (uint)0x10000)
- {
- if(leftBits != (uint)0xFEFF)
- {
- ++length;
- }
- }
- else if(leftBits < (uint)0x110000)
- {
- length += 2;
- }
- else if(throwOnInvalid)
- {
- throw new ArgumentException
- (_("Arg_InvalidUTF8"), "bytes");
- }
- leftSize = 0;
+#if NET_2_0
+ // Internal version of "GetCharCount" which can handle a rolling
+ // state between multiple calls to this method.
+ private static int InternalGetCharCount (
+ byte[] bytes, int index, int count, uint leftOverBits,
+ uint leftOverCount, DecoderFallbackBuffer fallbackBuffer, bool flush)
+#else
+ private static int InternalGetCharCount (
+ byte[] bytes, int index, int count, uint leftOverBits,
+ uint leftOverCount, bool throwOnInvalid, bool flush)
+#endif
+ {
+ // Validate the parameters.
+ if (bytes == null) {
+ throw new ArgumentNullException ("bytes");
+ }
+ if (index < 0 || index > bytes.Length) {
+ throw new ArgumentOutOfRangeException ("index", _("ArgRange_Array"));
+ }
+ if (count < 0 || count > (bytes.Length - index)) {
+ throw new ArgumentOutOfRangeException ("count", _("ArgRange_Array"));
+ }
+
+ // Determine the number of characters that we have.
+ uint ch;
+ int length = 0;
+ uint leftBits = leftOverBits;
+ uint leftSoFar = (leftOverCount & (uint)0x0F);
+ uint leftSize = ((leftOverCount >> 4) & (uint)0x0F);
+ while (count > 0) {
+ ch = (uint)(bytes[index++]);
+ --count;
+ if (leftSize == 0) {
+ // Process a UTF-8 start character.
+ if (ch < (uint)0x0080) {
+ // Single-byte UTF-8 character.
+ ++length;
+ } else if ((ch & (uint)0xE0) == (uint)0xC0) {
+ // Double-byte UTF-8 character.
+ leftBits = (ch & (uint)0x1F);
+ leftSoFar = 1;
+ leftSize = 2;
+ } else if ((ch & (uint)0xF0) == (uint)0xE0) {
+ // Three-byte UTF-8 character.
+ leftBits = (ch & (uint)0x0F);
+ leftSoFar = 1;
+ leftSize = 3;
+ } else if ((ch & (uint)0xF8) == (uint)0xF0) {
+ // Four-byte UTF-8 character.
+ leftBits = (ch & (uint)0x07);
+ leftSoFar = 1;
+ leftSize = 4;
+ } else if ((ch & (uint)0xFC) == (uint)0xF8) {
+ // Five-byte UTF-8 character.
+ leftBits = (ch & (uint)0x03);
+ leftSoFar = 1;
+ leftSize = 5;
+ } else if ((ch & (uint)0xFE) == (uint)0xFC) {
+ // Six-byte UTF-8 character.
+ leftBits = (ch & (uint)0x03);
+ leftSoFar = 1;
+ leftSize = 6;
+ } else {
+ // Invalid UTF-8 start character.
+#if NET_2_0
+ length += Fallback (fallbackBuffer, bytes, index - 1);
+#else
+ if (throwOnInvalid)
+ throw new ArgumentException (_("Arg_InvalidUTF8"), "bytes");
+#endif
+ }
+ } else {
+ // Process an extra byte in a multi-byte sequence.
+ if ((ch & (uint)0xC0) == (uint)0x80) {
+ leftBits = ((leftBits << 6) | (ch & (uint)0x3F));
+ if (++leftSoFar >= leftSize) {
+ // We have a complete character now.
+ if (leftBits < (uint)0x10000) {
+ // is it an overlong ?
+ bool overlong = false;
+ switch (leftSize) {
+ case 2:
+ overlong = (leftBits <= 0x7F);
+ break;
+ case 3:
+ overlong = (leftBits <= 0x07FF);
+ break;
+ case 4:
+ overlong = (leftBits <= 0xFFFF);
+ break;
+ case 5:
+ overlong = (leftBits <= 0x1FFFFF);
+ break;
+ case 6:
+ overlong = (leftBits <= 0x03FFFFFF);
+ break;
}
- }
- else
- {
- // Invalid UTF-8 sequence: clear and restart.
- if(throwOnInvalid)
- {
- throw new ArgumentException
- (_("Arg_InvalidUTF8"), "bytes");
+ if (overlong) {
+#if NET_2_0
+ length += Fallback (fallbackBuffer, bytes, index - 1);
+#else
+ if (throwOnInvalid)
+ throw new ArgumentException (_("Overlong"), leftBits.ToString ());
+#endif
}
- leftSize = 0;
- --index;
- ++count;
- }
+ else
+ ++length;
+ } else if (leftBits < (uint)0x110000) {
+ length += 2;
+ } else {
+#if NET_2_0
+ length += Fallback (fallbackBuffer, bytes, index - 1);
+#else
+ if (throwOnInvalid)
+ throw new ArgumentException (_("Arg_InvalidUTF8"), "bytes");
+#endif
+ }
+ leftSize = 0;
}
+ } else {
+ // Invalid UTF-8 sequence: clear and restart.
+#if NET_2_0
+ length += Fallback (fallbackBuffer, bytes, index - 1);
+#else
+ if (throwOnInvalid)
+ throw new ArgumentException (_("Arg_InvalidUTF8"), "bytes");
+#endif
+ leftSize = 0;
+ --index;
+ ++count;
}
- if(flush && leftSize != 0 && throwOnInvalid)
- {
- // We had left-over bytes that didn't make up
- // a complete UTF-8 character sequence.
- throw new ArgumentException
- (_("Arg_InvalidUTF8"), "bytes");
- }
-
- // Return the final length to the caller.
- return length;
}
+ }
+ if (flush && leftSize != 0) {
+ // We had left-over bytes that didn't make up
+ // a complete UTF-8 character sequence.
+#if NET_2_0
+ length += Fallback (fallbackBuffer, bytes, index - 1);
+#else
+ if (throwOnInvalid)
+ throw new ArgumentException (_("Arg_InvalidUTF8"), "bytes");
+#endif
+ }
+
+ // Return the final length to the caller.
+ return length;
+ }
+
+#if NET_2_0
+ // for GetCharCount()
+ static int Fallback (DecoderFallbackBuffer buffer, byte [] bytes, int index)
+ {
+ buffer.Fallback (bytes, index - 1);
+ return buffer.Remaining;
+ }
+
+ // for GetChars()
+ static void Fallback (DecoderFallbackBuffer buffer, byte [] bytes, int byteIndex,
+ char [] chars, ref int charIndex)
+ {
+ buffer.Fallback (bytes, byteIndex - 1);
+ while (buffer.Remaining > 0)
+ chars [charIndex++] = buffer.GetNextChar ();
+ }
+#endif
// Get the number of characters needed to decode a byte buffer.
- public override int GetCharCount(byte[] bytes, int index, int count)
- {
- return InternalGetCharCount(bytes, index, count, 0, 0,
- throwOnInvalid, true);
- }
+ public override int GetCharCount (byte[] bytes, int index, int count)
+ {
+#if NET_2_0
+ return InternalGetCharCount (bytes, index, count, 0, 0, DecoderFallback.CreateFallbackBuffer (), true);
+#else
+ return InternalGetCharCount (bytes, index, count, 0, 0, throwOnInvalid, true);
+#endif
+ }
// Get the characters that result from decoding a byte buffer.
- private static int InternalGetChars(byte[] bytes, int byteIndex,
- int byteCount, char[] chars,
- int charIndex, ref uint leftOverBits,
- ref uint leftOverCount,
- bool throwOnInvalid, bool flush)
- {
- // Validate the parameters.
- if(bytes == null)
- {
- throw new ArgumentNullException("bytes");
- }
- if(chars == null)
- {
- throw new ArgumentNullException("chars");
- }
- if(byteIndex < 0 || byteIndex > bytes.Length)
- {
- throw new ArgumentOutOfRangeException
- ("byteIndex", _("ArgRange_Array"));
- }
- if(byteCount < 0 || byteCount > (bytes.Length - byteIndex))
- {
- throw new ArgumentOutOfRangeException
- ("byteCount", _("ArgRange_Array"));
- }
- if(charIndex < 0 || charIndex > chars.Length)
- {
- throw new ArgumentOutOfRangeException
- ("charIndex", _("ArgRange_Array"));
- }
-
- // Convert the bytes into the output buffer.
- uint ch;
- int length = chars.Length;
- int posn = charIndex;
- uint leftBits = leftOverBits;
- uint leftSoFar = (leftOverCount & (uint)0x0F);
- uint leftSize = ((leftOverCount >> 4) & (uint)0x0F);
- while(byteCount > 0)
- {
- // Fetch the next character from the byte buffer.
- ch = (uint)(bytes[byteIndex++]);
- --byteCount;
- if(leftSize == 0)
- {
- // Process a UTF-8 start character.
- if(ch < (uint)0x0080)
- {
- // Single-byte UTF-8 character.
- if(posn >= length)
- {
- throw new ArgumentException
- (_("Arg_InsufficientSpace"), "chars");
+#if NET_2_0
+ private static int InternalGetChars (
+ byte[] bytes, int byteIndex, int byteCount, char[] chars,
+ int charIndex, ref uint leftOverBits, ref uint leftOverCount,
+ DecoderFallbackBuffer fallbackBuffer, bool flush)
+#else
+ private static int InternalGetChars (
+ byte[] bytes, int byteIndex, int byteCount, char[] chars,
+ int charIndex, ref uint leftOverBits, ref uint leftOverCount,
+ bool throwOnInvalid, bool flush)
+#endif
+ {
+ // Validate the parameters.
+ if (bytes == null) {
+ throw new ArgumentNullException ("bytes");
+ }
+ if (chars == null) {
+ throw new ArgumentNullException ("chars");
+ }
+ if (byteIndex < 0 || byteIndex > bytes.Length) {
+ throw new ArgumentOutOfRangeException ("byteIndex", _("ArgRange_Array"));
+ }
+ if (byteCount < 0 || byteCount > (bytes.Length - byteIndex)) {
+ throw new ArgumentOutOfRangeException ("byteCount", _("ArgRange_Array"));
+ }
+ if (charIndex < 0 || charIndex > chars.Length) {
+ throw new ArgumentOutOfRangeException ("charIndex", _("ArgRange_Array"));
+ }
+
+ if (charIndex == chars.Length)
+ return 0;
+
+ // Convert the bytes into the output buffer.
+ uint ch;
+ int length = chars.Length;
+ int posn = charIndex;
+ uint leftBits = leftOverBits;
+ uint leftSoFar = (leftOverCount & (uint)0x0F);
+ uint leftSize = ((leftOverCount >> 4) & (uint)0x0F);
+ while (byteCount > 0) {
+ // Fetch the next character from the byte buffer.
+ ch = (uint)(bytes[byteIndex++]);
+ --byteCount;
+ if (leftSize == 0) {
+ // Process a UTF-8 start character.
+ if (ch < (uint)0x0080) {
+ // Single-byte UTF-8 character.
+ if (posn >= length) {
+ throw new ArgumentException (_("Arg_InsufficientSpace"), "chars");
+ }
+ chars[posn++] = (char)ch;
+ } else if ((ch & (uint)0xE0) == (uint)0xC0) {
+ // Double-byte UTF-8 character.
+ leftBits = (ch & (uint)0x1F);
+ leftSoFar = 1;
+ leftSize = 2;
+ } else if ((ch & (uint)0xF0) == (uint)0xE0) {
+ // Three-byte UTF-8 character.
+ leftBits = (ch & (uint)0x0F);
+ leftSoFar = 1;
+ leftSize = 3;
+ } else if ((ch & (uint)0xF8) == (uint)0xF0) {
+ // Four-byte UTF-8 character.
+ leftBits = (ch & (uint)0x07);
+ leftSoFar = 1;
+ leftSize = 4;
+ } else if ((ch & (uint)0xFC) == (uint)0xF8) {
+ // Five-byte UTF-8 character.
+ leftBits = (ch & (uint)0x03);
+ leftSoFar = 1;
+ leftSize = 5;
+ } else if ((ch & (uint)0xFE) == (uint)0xFC) {
+ // Six-byte UTF-8 character.
+ leftBits = (ch & (uint)0x03);
+ leftSoFar = 1;
+ leftSize = 6;
+ } else {
+ // Invalid UTF-8 start character.
+#if NET_2_0
+ Fallback (fallbackBuffer, bytes, byteIndex, chars, ref posn);
+#else
+ if (throwOnInvalid)
+ throw new ArgumentException (_("Arg_InvalidUTF8"), "bytes");
+#endif
+ }
+ } else {
+ // Process an extra byte in a multi-byte sequence.
+ if ((ch & (uint)0xC0) == (uint)0x80) {
+ leftBits = ((leftBits << 6) | (ch & (uint)0x3F));
+ if (++leftSoFar >= leftSize) {
+ // We have a complete character now.
+ if (leftBits < (uint)0x10000) {
+ // is it an overlong ?
+ bool overlong = false;
+ switch (leftSize) {
+ case 2:
+ overlong = (leftBits <= 0x7F);
+ break;
+ case 3:
+ overlong = (leftBits <= 0x07FF);
+ break;
+ case 4:
+ overlong = (leftBits <= 0xFFFF);
+ break;
+ case 5:
+ overlong = (leftBits <= 0x1FFFFF);
+ break;
+ case 6:
+ overlong = (leftBits <= 0x03FFFFFF);
+ break;
}
- chars[posn++] = (char)ch;
- }
- else if((ch & (uint)0xE0) == (uint)0xC0)
- {
- // Double-byte UTF-8 character.
- leftBits = (ch & (uint)0x1F);
- leftSoFar = 1;
- leftSize = 2;
- }
- else if((ch & (uint)0xF0) == (uint)0xE0)
- {
- // Three-byte UTF-8 character.
- leftBits = (ch & (uint)0x0F);
- leftSoFar = 1;
- leftSize = 3;
- }
- else if((ch & (uint)0xF8) == (uint)0xF0)
- {
- // Four-byte UTF-8 character.
- leftBits = (ch & (uint)0x07);
- leftSoFar = 1;
- leftSize = 4;
- }
- else if((ch & (uint)0xFC) == (uint)0xF8)
- {
- // Five-byte UTF-8 character.
- leftBits = (ch & (uint)0x03);
- leftSoFar = 1;
- leftSize = 5;
- }
- else if((ch & (uint)0xFC) == (uint)0xFC)
- {
- // Six-byte UTF-8 character.
- leftBits = (ch & (uint)0x03);
- leftSoFar = 1;
- leftSize = 6;
- }
- else
- {
- // Invalid UTF-8 start character.
- if(throwOnInvalid)
- {
- throw new ArgumentException
- (_("Arg_InvalidUTF8"), "bytes");
+ if (overlong) {
+#if NET_2_0
+ Fallback (fallbackBuffer, bytes, byteIndex, chars, ref posn);
+#else
+ if (throwOnInvalid)
+ throw new ArgumentException (_("Overlong"), leftBits.ToString ());
+#endif
}
- }
- }
- else
- {
- // Process an extra byte in a multi-byte sequence.
- if((ch & (uint)0xC0) == (uint)0x80)
- {
- leftBits = ((leftBits << 6) | (ch & (uint)0x3F));
- if(++leftSoFar >= leftSize)
- {
- // We have a complete character now.
- if(leftBits < (uint)0x10000)
- {
- if(leftBits != (uint)0xFEFF)
- {
- if(posn >= length)
- {
- throw new ArgumentException
- (_("Arg_InsufficientSpace"),
- "chars");
- }
- chars[posn++] = (char)leftBits;
- }
- }
- else if(leftBits < (uint)0x110000)
- {
- if((posn + 2) > length)
- {
- throw new ArgumentException
- (_("Arg_InsufficientSpace"),
- "chars");
- }
- leftBits -= (uint)0x10000;
- chars[posn++] = (char)((leftBits >> 10) +
- (uint)0xD800);
- chars[posn++] =
- (char)((leftBits & (uint)0x3FF) +
- (uint)0xDC00);
- }
- else if(throwOnInvalid)
- {
+ else {
+ if (posn >= length) {
throw new ArgumentException
- (_("Arg_InvalidUTF8"), "bytes");
+ (_("Arg_InsufficientSpace"), "chars");
}
- leftSize = 0;
+ chars[posn++] = (char)leftBits;
}
- }
- else
- {
- // Invalid UTF-8 sequence: clear and restart.
- if(throwOnInvalid)
- {
+ } else if (leftBits < (uint)0x110000) {
+ if ((posn + 2) > length) {
throw new ArgumentException
- (_("Arg_InvalidUTF8"), "bytes");
+ (_("Arg_InsufficientSpace"), "chars");
}
- leftSize = 0;
- --byteIndex;
- ++byteCount;
- }
+ leftBits -= (uint)0x10000;
+ chars[posn++] = (char)((leftBits >> 10) +
+ (uint)0xD800);
+ chars[posn++] =
+ (char)((leftBits & (uint)0x3FF) + (uint)0xDC00);
+ } else {
+#if NET_2_0
+ Fallback (fallbackBuffer, bytes, byteIndex, chars, ref posn);
+#else
+ if (throwOnInvalid)
+ throw new ArgumentException (_("Arg_InvalidUTF8"), "bytes");
+#endif
+ }
+ leftSize = 0;
}
+ } else {
+ // Invalid UTF-8 sequence: clear and restart.
+#if NET_2_0
+ Fallback (fallbackBuffer, bytes, byteIndex, chars, ref posn);
+#else
+ if (throwOnInvalid)
+ throw new ArgumentException (_("Arg_InvalidUTF8"), "bytes");
+#endif
+ leftSize = 0;
+ --byteIndex;
+ ++byteCount;
}
- if(flush && leftSize != 0 && throwOnInvalid)
- {
- // We had left-over bytes that didn't make up
- // a complete UTF-8 character sequence.
- throw new ArgumentException
- (_("Arg_InvalidUTF8"), "bytes");
- }
- leftOverBits = leftBits;
- leftOverCount = (leftSoFar | (leftSize << 4));
-
- // Return the final length to the caller.
- return posn - charIndex;
}
+ }
+ if (flush && leftSize != 0) {
+ // We had left-over bytes that didn't make up
+ // a complete UTF-8 character sequence.
+#if NET_2_0
+ Fallback (fallbackBuffer, bytes, byteIndex, chars, ref posn);
+#else
+ if (throwOnInvalid)
+ throw new ArgumentException (_("Arg_InvalidUTF8"), "bytes");
+#endif
+ }
+ leftOverBits = leftBits;
+ leftOverCount = (leftSoFar | (leftSize << 4));
+
+ // Return the final length to the caller.
+ return posn - charIndex;
+ }
// Get the characters that result from decoding a byte buffer.
- public override int GetChars(byte[] bytes, int byteIndex, int byteCount,
+ public override int GetChars (byte[] bytes, int byteIndex, int byteCount,
char[] chars, int charIndex)
- {
- uint leftOverBits = 0;
- uint leftOverCount = 0;
- return InternalGetChars(bytes, byteIndex, byteCount,
- chars, charIndex, ref leftOverBits,
- ref leftOverCount, throwOnInvalid,
- true);
- }
+ {
+ uint leftOverBits = 0;
+ uint leftOverCount = 0;
+#if NET_2_0
+ return InternalGetChars (bytes, byteIndex, byteCount, chars,
+ charIndex, ref leftOverBits, ref leftOverCount, DecoderFallback.CreateFallbackBuffer (), true);
+#else
+ return InternalGetChars (bytes, byteIndex, byteCount, chars,
+ charIndex, ref leftOverBits, ref leftOverCount, throwOnInvalid, true);
+#endif
+ }
// Get the maximum number of bytes needed to encode a
// specified number of characters.
- public override int GetMaxByteCount(int charCount)
- {
- if(charCount < 0)
- {
- throw new ArgumentOutOfRangeException
- ("charCount", _("ArgRange_NonNegative"));
- }
- return charCount * 4 + (emitIdentifier ? 3 : 0);
- }
+ public override int GetMaxByteCount (int charCount)
+ {
+ if (charCount < 0) {
+ throw new ArgumentOutOfRangeException ("charCount", _("ArgRange_NonNegative"));
+ }
+ return charCount * 4;
+ }
// Get the maximum number of characters needed to decode a
// specified number of bytes.
- public override int GetMaxCharCount(int byteCount)
- {
- if(byteCount < 0)
- {
- throw new ArgumentOutOfRangeException
- ("byteCount", _("ArgRange_NonNegative"));
- }
- return byteCount;
- }
+ public override int GetMaxCharCount (int byteCount)
+ {
+ if (byteCount < 0) {
+ throw new ArgumentOutOfRangeException ("byteCount", _("ArgRange_NonNegative"));
+ }
+ return byteCount;
+ }
// Get a UTF8-specific decoder that is attached to this instance.
- public override Decoder GetDecoder()
- {
- return new UTF8Decoder(throwOnInvalid);
- }
+ public override Decoder GetDecoder ()
+ {
+#if NET_2_0
+ return new UTF8Decoder (DecoderFallback);
+#else
+ return new UTF8Decoder (throwOnInvalid);
+#endif
+ }
// Get a UTF8-specific encoder that is attached to this instance.
- public override Encoder GetEncoder()
- {
- return new UTF8Encoder(emitIdentifier);
- }
+ public override Encoder GetEncoder ()
+ {
+ return new UTF8Encoder (emitIdentifier);
+ }
// Get the UTF8 preamble.
- public override byte[] GetPreamble()
- {
- if(emitIdentifier)
- {
- byte[] pre = new byte [3];
- pre[0] = (byte)0xEF;
- pre[1] = (byte)0xBB;
- pre[2] = (byte)0xBF;
- return pre;
- }
- else
- {
- return new byte [0];
- }
- }
+ public override byte[] GetPreamble ()
+ {
+ if (emitIdentifier) {
+ byte[] pre = new byte [3];
+ pre[0] = (byte)0xEF;
+ pre[1] = (byte)0xBB;
+ pre[2] = (byte)0xBF;
+ return pre;
+ } else {
+ return new byte [0];
+ }
+ }
// Determine if this object is equal to another.
- public override bool Equals(Object value)
- {
- UTF8Encoding enc = (value as UTF8Encoding);
- if(enc != null)
- {
- return (codePage == enc.codePage &&
- emitIdentifier == enc.emitIdentifier &&
- throwOnInvalid == enc.throwOnInvalid);
- }
- else
- {
- return false;
- }
- }
+ public override bool Equals (Object value)
+ {
+ UTF8Encoding enc = (value as UTF8Encoding);
+ if (enc != null) {
+#if NET_2_0
+ return (codePage == enc.codePage &&
+ emitIdentifier == enc.emitIdentifier &&
+ DecoderFallback == enc.DecoderFallback &&
+ EncoderFallback == enc.EncoderFallback);
+#else
+ return (codePage == enc.codePage &&
+ emitIdentifier == enc.emitIdentifier &&
+ throwOnInvalid == enc.throwOnInvalid);
+#endif
+ } else {
+ return false;
+ }
+ }
// Get the hash code for this object.
- public override int GetHashCode()
- {
- return base.GetHashCode();
- }
-
-#if !ECMA_COMPAT
-
- // Get the mail body name for this encoding.
- public override String BodyName
- {
- get
- {
- return "utf-8";
- }
- }
-
- // Get the human-readable name for this encoding.
- public override String EncodingName
- {
- get
- {
- return "Unicode (UTF-8)";
- }
- }
-
- // Get the mail agent header name for this encoding.
- public override String HeaderName
- {
- get
- {
- return "utf-8";
- }
- }
-
- // Determine if this encoding can be displayed in a Web browser.
- public override bool IsBrowserDisplay
- {
- get
- {
- return true;
- }
- }
-
- // Determine if this encoding can be saved from a Web browser.
- public override bool IsBrowserSave
- {
- get
- {
- return true;
- }
- }
-
- // Determine if this encoding can be displayed in a mail/news agent.
- public override bool IsMailNewsDisplay
- {
- get
- {
- return true;
- }
- }
-
- // Determine if this encoding can be saved from a mail/news agent.
- public override bool IsMailNewsSave
- {
- get
- {
- return true;
- }
- }
-
- // Get the IANA-preferred Web name for this encoding.
- public override String WebName
- {
- get
- {
- return "utf-8";
- }
- }
-
- // Get the Windows code page represented by this object.
- public override int WindowsCodePage
- {
- get
- {
- return UnicodeEncoding.UNICODE_CODE_PAGE;
- }
- }
-
-#endif // !ECMA_COMPAT
+ public override int GetHashCode ()
+ {
+ return base.GetHashCode ();
+ }
+
+ public override byte [] GetBytes (String s)
+ {
+ if (s == null)
+ throw new ArgumentNullException ("s");
+
+ int length = GetByteCount (s);
+ byte [] bytes = new byte [length];
+ GetBytes (s, 0, s.Length, bytes, 0);
+ return bytes;
+ }
// UTF-8 decoder implementation.
[Serializable]
- private sealed class UTF8Decoder : Decoder
+ private class UTF8Decoder : Decoder
{
+#if !NET_2_0
private bool throwOnInvalid;
+#endif
private uint leftOverBits;
private uint leftOverCount;
// Constructor.
- public UTF8Decoder(bool throwOnInvalid)
- {
- this.throwOnInvalid = throwOnInvalid;
- leftOverBits = 0;
- leftOverCount = 0;
- }
+#if NET_2_0
+ public UTF8Decoder (DecoderFallback fallback)
+#else
+ public UTF8Decoder (bool throwOnInvalid)
+#endif
+ {
+#if NET_2_0
+ Fallback = fallback;
+#else
+ this.throwOnInvalid = throwOnInvalid;
+#endif
+ leftOverBits = 0;
+ leftOverCount = 0;
+ }
// Override inherited methods.
- public override int GetCharCount(byte[] bytes, int index, int count)
- {
- return InternalGetCharCount(bytes, index, count,
- leftOverBits, leftOverCount,
- throwOnInvalid, false);
- }
- public override int GetChars(byte[] bytes, int byteIndex,
- int byteCount, char[] chars,
- int charIndex)
- {
- return InternalGetChars(bytes, byteIndex, byteCount,
- chars, charIndex,
- ref leftOverBits,
- ref leftOverCount,
- throwOnInvalid, false);
- }
+ public override int GetCharCount (byte[] bytes, int index, int count)
+ {
+#if NET_2_0
+ return InternalGetCharCount (bytes, index, count,
+ leftOverBits, leftOverCount, FallbackBuffer, false);
+#else
+ return InternalGetCharCount (bytes, index, count,
+ leftOverBits, leftOverCount, throwOnInvalid, false);
+#endif
+ }
+ public override int GetChars (byte[] bytes, int byteIndex,
+ int byteCount, char[] chars, int charIndex)
+ {
+#if NET_2_0
+ return InternalGetChars (bytes, byteIndex, byteCount,
+ chars, charIndex, ref leftOverBits, ref leftOverCount, FallbackBuffer, false);
+#else
+ return InternalGetChars (bytes, byteIndex, byteCount,
+ chars, charIndex, ref leftOverBits, ref leftOverCount, throwOnInvalid, false);
+#endif
+ }
} // class UTF8Decoder
// UTF-8 encoder implementation.
[Serializable]
- private sealed class UTF8Encoder : Encoder
+ private class UTF8Encoder : Encoder
{
private bool emitIdentifier;
private uint leftOver;
// Constructor.
- public UTF8Encoder(bool emitIdentifier)
- {
- this.emitIdentifier = emitIdentifier;
- leftOver = 0;
- }
+ public UTF8Encoder (bool emitIdentifier)
+ {
+ this.emitIdentifier = emitIdentifier;
+ leftOver = 0;
+ }
// Override inherited methods.
- public override int GetByteCount(char[] chars, int index,
- int count, bool flush)
- {
- return InternalGetByteCount
- (chars, index, count, leftOver,
- emitIdentifier, flush);
- }
- public override int GetBytes(char[] chars, int charIndex,
- int charCount, byte[] bytes,
- int byteCount, bool flush)
- {
- int result;
- result = InternalGetBytes
- (chars, charIndex, charCount, bytes, byteCount,
- ref leftOver, emitIdentifier, flush);
- emitIdentifier = false;
- return result;
- }
+ public override int GetByteCount (char[] chars, int index,
+ int count, bool flush)
+ {
+ return InternalGetByteCount (chars, index, count, leftOver, flush);
+ }
+ public override int GetBytes (char[] chars, int charIndex,
+ int charCount, byte[] bytes, int byteCount, bool flush)
+ {
+ int result;
+ result = InternalGetBytes (chars, charIndex, charCount, bytes, byteCount, ref leftOver, flush);
+ emitIdentifier = false;
+ return result;
+ }
} // class UTF8Encoder
projects / mono.git / blobdiff