Files
mono/mcs/class/corlib/System.Text/UTF8Encoding.cs
T
Paolo Molaro feee3a2d52 Wed Aug 21 20:02:04 CEST 2002 Paolo Molaro <[email protected]>
* *.cs: imported the code donated by Rhys Weatherley
	<[email protected]>.

svn path=/trunk/mcs/; revision=6863
2002-08-21 18:04:52 +00:00

1040 lines
26 KiB
C#
Executable File

/*
* UTF8Encoding.cs - Implementation of the "System.Text.UTF8Encoding" class.
*
* Copyright (c) 2001, 2002 Southern Storm Software, Pty Ltd
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*/
namespace System.Text
{
using System;
public class UTF8Encoding : Encoding
{
// Magic number used by Windows for UTF-8.
internal const int UTF8_CODE_PAGE = 65001;
// Internal state.
private bool emitIdentifier;
private bool throwOnInvalid;
// 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;
}
// 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.
length += 3;
}
// Return the final length to the caller.
return length + (emitIdentifier ? 3 : 0);
}
// 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);
}
// 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;
}
--count;
}
// Return the final length to the caller.
return length + (emitIdentifier ? 3 : 0);
}
// 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;
// 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,
byte[] bytes, int byteIndex)
{
uint leftOver = 0;
return InternalGetBytes(chars, charIndex, charCount,
bytes, byteIndex, ref leftOver,
emitIdentifier, true);
}
// Convenience wrappers for "GetBytes".
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++];
--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));
}
}
// 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;
}
}
else
{
// Invalid UTF-8 sequence: clear and restart.
if(throwOnInvalid)
{
throw new ArgumentException
(_("Arg_InvalidUTF8"), "bytes");
}
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;
}
// 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);
}
// 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");
}
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");
}
}
}
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)
{
throw new ArgumentException
(_("Arg_InvalidUTF8"), "bytes");
}
leftSize = 0;
}
}
else
{
// Invalid UTF-8 sequence: clear and restart.
if(throwOnInvalid)
{
throw new ArgumentException
(_("Arg_InvalidUTF8"), "bytes");
}
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;
}
// Get the characters that result from decoding a byte buffer.
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);
}
// 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);
}
// 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;
}
// Get a UTF8-specific decoder that is attached to this instance.
public override Decoder GetDecoder()
{
return new UTF8Decoder(throwOnInvalid);
}
// Get a UTF8-specific encoder that is attached to this instance.
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];
}
}
// 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;
}
}
// 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
// UTF-8 decoder implementation.
private sealed class UTF8Decoder : Decoder
{
private bool throwOnInvalid;
private uint leftOverBits;
private uint leftOverCount;
// Constructor.
public UTF8Decoder(bool throwOnInvalid)
{
this.throwOnInvalid = throwOnInvalid;
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);
}
} // class UTF8Decoder
// UTF-8 encoder implementation.
private sealed class UTF8Encoder : Encoder
{
private bool emitIdentifier;
private uint leftOver;
// Constructor.
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;
}
} // class UTF8Encoder
}; // class UTF8Encoding
}; // namespace System.Text