|
//-----------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------------
namespace System.Xml
{
using System;
using System.IO;
using System.Text;
using System.Runtime.Serialization;
// This wrapper does not support seek.
// Constructors consume/emit byte order mark.
// Supports: UTF-8, Unicode, BigEndianUnicode
// ASSUMPTION (Microsoft): This class will only be used for EITHER reading OR writing. It can be done, it would just mean more buffers.
// ASSUMPTION (Microsoft): The byte buffer is large enough to hold the declaration
// ASSUMPTION (Microsoft): The buffer manipulation methods (FillBuffer/Compare/etc.) will only be used to parse the declaration
// during construction.
class EncodingStreamWrapper : Stream
{
enum SupportedEncoding { UTF8, UTF16LE, UTF16BE, None }
static readonly UTF8Encoding SafeUTF8 = new UTF8Encoding(false, false);
static readonly UnicodeEncoding SafeUTF16 = new UnicodeEncoding(false, false, false);
static readonly UnicodeEncoding SafeBEUTF16 = new UnicodeEncoding(true, false, false);
static readonly UTF8Encoding ValidatingUTF8 = new UTF8Encoding(false, true);
static readonly UnicodeEncoding ValidatingUTF16 = new UnicodeEncoding(false, false, true);
static readonly UnicodeEncoding ValidatingBEUTF16 = new UnicodeEncoding(true, false, true);
const int BufferLength = 128;
// UTF-8 is fastpath, so that's how these are stored
// Compare methods adapt to unicodes.
static readonly byte[] encodingAttr = new byte[] { (byte)'e', (byte)'n', (byte)'c', (byte)'o', (byte)'d', (byte)'i', (byte)'n', (byte)'g' };
static readonly byte[] encodingUTF8 = new byte[] { (byte)'u', (byte)'t', (byte)'f', (byte)'-', (byte)'8' };
static readonly byte[] encodingUnicode = new byte[] { (byte)'u', (byte)'t', (byte)'f', (byte)'-', (byte)'1', (byte)'6' };
static readonly byte[] encodingUnicodeLE = new byte[] { (byte)'u', (byte)'t', (byte)'f', (byte)'-', (byte)'1', (byte)'6', (byte)'l', (byte)'e' };
static readonly byte[] encodingUnicodeBE = new byte[] { (byte)'u', (byte)'t', (byte)'f', (byte)'-', (byte)'1', (byte)'6', (byte)'b', (byte)'e' };
SupportedEncoding encodingCode;
Encoding encoding;
Encoder enc;
Decoder dec;
bool isReading;
Stream stream;
char[] chars;
byte[] bytes;
int byteOffset;
int byteCount;
byte[] byteBuffer = new byte[1];
// Reading constructor
public EncodingStreamWrapper(Stream stream, Encoding encoding)
{
try
{
this.isReading = true;
this.stream = new BufferedStream(stream);
// Decode the expected encoding
SupportedEncoding expectedEnc = GetSupportedEncoding(encoding);
// Get the byte order mark so we can determine the encoding
// May want to try to delay allocating everything until we know the BOM
SupportedEncoding declEnc = ReadBOMEncoding(encoding == null);
// Check that the expected encoding matches the decl encoding.
if (expectedEnc != SupportedEncoding.None && expectedEnc != declEnc)
ThrowExpectedEncodingMismatch(expectedEnc, declEnc);
// Fastpath: UTF-8 BOM
if (declEnc == SupportedEncoding.UTF8)
{
// Fastpath: UTF-8 BOM, No declaration
FillBuffer(2);
if (bytes[byteOffset + 1] != '?' || bytes[byteOffset] != '<')
{
return;
}
FillBuffer(BufferLength);
CheckUTF8DeclarationEncoding(bytes, byteOffset, byteCount, declEnc, expectedEnc);
}
else
{
// Convert to UTF-8
EnsureBuffers();
FillBuffer((BufferLength - 1) * 2);
SetReadDocumentEncoding(declEnc);
CleanupCharBreak();
int count = this.encoding.GetChars(bytes, byteOffset, byteCount, chars, 0);
byteOffset = 0;
byteCount = ValidatingUTF8.GetBytes(chars, 0, count, bytes, 0);
// Check for declaration
if (bytes[1] == '?' && bytes[0] == '<')
{
CheckUTF8DeclarationEncoding(bytes, 0, byteCount, declEnc, expectedEnc);
}
else
{
// Declaration required if no out-of-band encoding
if (expectedEnc == SupportedEncoding.None)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.XmlDeclarationRequired)));
}
}
}
catch (DecoderFallbackException ex)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.XmlInvalidBytes), ex));
}
}
void SetReadDocumentEncoding(SupportedEncoding e)
{
EnsureBuffers();
this.encodingCode = e;
this.encoding = GetEncoding(e);
}
static Encoding GetEncoding(SupportedEncoding e)
{
switch (e)
{
case SupportedEncoding.UTF8:
return ValidatingUTF8;
case SupportedEncoding.UTF16LE:
return ValidatingUTF16;
case SupportedEncoding.UTF16BE:
return ValidatingBEUTF16;
default:
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.XmlEncodingNotSupported)));
}
}
static Encoding GetSafeEncoding(SupportedEncoding e)
{
switch (e)
{
case SupportedEncoding.UTF8:
return SafeUTF8;
case SupportedEncoding.UTF16LE:
return SafeUTF16;
case SupportedEncoding.UTF16BE:
return SafeBEUTF16;
default:
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.XmlEncodingNotSupported)));
}
}
static string GetEncodingName(SupportedEncoding enc)
{
switch (enc)
{
case SupportedEncoding.UTF8:
return "utf-8";
case SupportedEncoding.UTF16LE:
return "utf-16LE";
case SupportedEncoding.UTF16BE:
return "utf-16BE";
default:
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.XmlEncodingNotSupported)));
}
}
static SupportedEncoding GetSupportedEncoding(Encoding encoding)
{
if (encoding == null)
return SupportedEncoding.None;
else if (encoding.WebName == ValidatingUTF8.WebName)
return SupportedEncoding.UTF8;
else if (encoding.WebName == ValidatingUTF16.WebName)
return SupportedEncoding.UTF16LE;
else if (encoding.WebName == ValidatingBEUTF16.WebName)
return SupportedEncoding.UTF16BE;
else
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.XmlEncodingNotSupported)));
}
// Writing constructor
public EncodingStreamWrapper(Stream stream, Encoding encoding, bool emitBOM)
{
this.isReading = false;
this.encoding = encoding;
this.stream = new BufferedStream(stream);
// Set the encoding code
this.encodingCode = GetSupportedEncoding(encoding);
if (encodingCode != SupportedEncoding.UTF8)
{
EnsureBuffers();
dec = ValidatingUTF8.GetDecoder();
enc = this.encoding.GetEncoder();
// Emit BOM
if (emitBOM)
{
byte[] bom = this.encoding.GetPreamble();
if (bom.Length > 0)
this.stream.Write(bom, 0, bom.Length);
}
}
}
SupportedEncoding ReadBOMEncoding(bool notOutOfBand)
{
int b1 = this.stream.ReadByte();
int b2 = this.stream.ReadByte();
int b3 = this.stream.ReadByte();
int b4 = this.stream.ReadByte();
// Premature end of stream
if (b4 == -1)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.UnexpectedEndOfFile)));
int preserve;
SupportedEncoding e = ReadBOMEncoding((byte)b1, (byte)b2, (byte)b3, (byte)b4, notOutOfBand, out preserve);
EnsureByteBuffer();
switch (preserve)
{
case 1:
bytes[0] = (byte)b4;
break;
case 2:
bytes[0] = (byte)b3;
bytes[1] = (byte)b4;
break;
case 4:
bytes[0] = (byte)b1;
bytes[1] = (byte)b2;
bytes[2] = (byte)b3;
bytes[3] = (byte)b4;
break;
}
byteCount = preserve;
return e;
}
static SupportedEncoding ReadBOMEncoding(byte b1, byte b2, byte b3, byte b4, bool notOutOfBand, out int preserve)
{
SupportedEncoding e = SupportedEncoding.UTF8; // Default
preserve = 0;
if (b1 == '<' && b2 != 0x00) // UTF-8, no BOM
{
e = SupportedEncoding.UTF8;
preserve = 4;
}
else if (b1 == 0xFF && b2 == 0xFE) // UTF-16 little endian
{
e = SupportedEncoding.UTF16LE;
preserve = 2;
}
else if (b1 == 0xFE && b2 == 0xFF) // UTF-16 big endian
{
e = SupportedEncoding.UTF16BE;
preserve = 2;
}
else if (b1 == 0x00 && b2 == '<') // UTF-16 big endian, no BOM
{
e = SupportedEncoding.UTF16BE;
if (notOutOfBand && (b3 != 0x00 || b4 != '?'))
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.XmlDeclMissing)));
preserve = 4;
}
else if (b1 == '<' && b2 == 0x00) // UTF-16 little endian, no BOM
{
e = SupportedEncoding.UTF16LE;
if (notOutOfBand && (b3 != '?' || b4 != 0x00))
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.XmlDeclMissing)));
preserve = 4;
}
else if (b1 == 0xEF && b2 == 0xBB) // UTF8 with BOM
{
// Encoding error
if (notOutOfBand && b3 != 0xBF)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.XmlBadBOM)));
preserve = 1;
}
else // Assume UTF8
{
preserve = 4;
}
return e;
}
void FillBuffer(int count)
{
count -= byteCount;
while (count > 0)
{
int read = stream.Read(bytes, byteOffset + byteCount, count);
if (read == 0)
break;
byteCount += read;
count -= read;
}
}
void EnsureBuffers()
{
EnsureByteBuffer();
if (chars == null)
chars = new char[BufferLength];
}
void EnsureByteBuffer()
{
if (bytes != null)
return;
bytes = new byte[BufferLength * 4];
byteOffset = 0;
byteCount = 0;
}
static void CheckUTF8DeclarationEncoding(byte[] buffer, int offset, int count, SupportedEncoding e, SupportedEncoding expectedEnc)
{
byte quot = 0;
int encEq = -1;
int max = offset + Math.Min(count, BufferLength);
// Encoding should be second "=", abort at first "?"
int i = 0;
int eq = 0;
for (i = offset + 2; i < max; i++) // Skip the "<?" so we don't get caught by the first "?"
{
if (quot != 0)
{
if (buffer[i] == quot)
{
quot = 0;
}
continue;
}
if (buffer[i] == (byte)'\'' || buffer[i] == (byte)'"')
{
quot = buffer[i];
}
else if (buffer[i] == (byte)'=')
{
if (eq == 1)
{
encEq = i;
break;
}
eq++;
}
else if (buffer[i] == (byte)'?') // Not legal character in a decl before second "="
{
break;
}
}
// No encoding found
if (encEq == -1)
{
if (e != SupportedEncoding.UTF8 && expectedEnc == SupportedEncoding.None)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.XmlDeclarationRequired)));
return;
}
if (encEq < 28) // Earliest second "=" can appear
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.XmlMalformedDecl)));
// Back off whitespace
for (i = encEq - 1; IsWhitespace(buffer[i]); i--);
// Check for encoding attribute
if (!Compare(encodingAttr, buffer, i - encodingAttr.Length + 1))
{
if (e != SupportedEncoding.UTF8 && expectedEnc == SupportedEncoding.None)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.XmlDeclarationRequired)));
return;
}
// Move ahead of whitespace
for (i = encEq + 1; i < max && IsWhitespace(buffer[i]); i++);
// Find the quotes
if (buffer[i] != '\'' && buffer[i] != '"')
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.XmlMalformedDecl)));
quot = buffer[i];
int q = i;
for (i = q + 1; buffer[i] != quot && i < max; ++i);
if (buffer[i] != quot)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.XmlMalformedDecl)));
int encStart = q + 1;
int encCount = i - encStart;
// lookup the encoding
SupportedEncoding declEnc = e;
if (encCount == encodingUTF8.Length && CompareCaseInsensitive(encodingUTF8, buffer, encStart))
{
declEnc = SupportedEncoding.UTF8;
}
else if (encCount == encodingUnicodeLE.Length && CompareCaseInsensitive(encodingUnicodeLE, buffer, encStart))
{
declEnc = SupportedEncoding.UTF16LE;
}
else if (encCount == encodingUnicodeBE.Length && CompareCaseInsensitive(encodingUnicodeBE, buffer, encStart))
{
declEnc = SupportedEncoding.UTF16BE;
}
else if (encCount == encodingUnicode.Length && CompareCaseInsensitive(encodingUnicode, buffer, encStart))
{
if (e == SupportedEncoding.UTF8)
ThrowEncodingMismatch(SafeUTF8.GetString(buffer, encStart, encCount), SafeUTF8.GetString(encodingUTF8, 0, encodingUTF8.Length));
}
else
{
ThrowEncodingMismatch(SafeUTF8.GetString(buffer, encStart, encCount), e);
}
if (e != declEnc)
ThrowEncodingMismatch(SafeUTF8.GetString(buffer, encStart, encCount), e);
}
static bool CompareCaseInsensitive(byte[] key, byte[] buffer, int offset)
{
for (int i = 0; i < key.Length; i++)
{
if (key[i] == buffer[offset + i])
continue;
if (key[i] != Char.ToLower((char)buffer[offset + i], System.Globalization.CultureInfo.InvariantCulture))
return false;
}
return true;
}
static bool Compare(byte[] key, byte[] buffer, int offset)
{
for (int i = 0; i < key.Length; i++)
{
if (key[i] != buffer[offset + i])
return false;
}
return true;
}
static bool IsWhitespace(byte ch)
{
return ch == (byte)' ' || ch == (byte)'\n' || ch == (byte)'\t' || ch == (byte)'\r';
}
internal static ArraySegment<byte> ProcessBuffer(byte[] buffer, int offset, int count, Encoding encoding)
{
if (count < 4)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.UnexpectedEndOfFile)));
try
{
int preserve;
ArraySegment<byte> seg;
SupportedEncoding expectedEnc = GetSupportedEncoding(encoding);
SupportedEncoding declEnc = ReadBOMEncoding(buffer[offset], buffer[offset + 1], buffer[offset + 2], buffer[offset + 3], encoding == null, out preserve);
if (expectedEnc != SupportedEncoding.None && expectedEnc != declEnc)
ThrowExpectedEncodingMismatch(expectedEnc, declEnc);
offset += 4 - preserve;
count -= 4 - preserve;
// Fastpath: UTF-8
char[] chars;
byte[] bytes;
Encoding localEnc;
if (declEnc == SupportedEncoding.UTF8)
{
// Fastpath: No declaration
if (buffer[offset + 1] != '?' || buffer[offset] != '<')
{
seg = new ArraySegment<byte>(buffer, offset, count);
return seg;
}
CheckUTF8DeclarationEncoding(buffer, offset, count, declEnc, expectedEnc);
seg = new ArraySegment<byte>(buffer, offset, count);
return seg;
}
// Convert to UTF-8
localEnc = GetSafeEncoding(declEnc);
int inputCount = Math.Min(count, BufferLength * 2);
chars = new char[localEnc.GetMaxCharCount(inputCount)];
int ccount = localEnc.GetChars(buffer, offset, inputCount, chars, 0);
bytes = new byte[ValidatingUTF8.GetMaxByteCount(ccount)];
int bcount = ValidatingUTF8.GetBytes(chars, 0, ccount, bytes, 0);
// Check for declaration
if (bytes[1] == '?' && bytes[0] == '<')
{
CheckUTF8DeclarationEncoding(bytes, 0, bcount, declEnc, expectedEnc);
}
else
{
// Declaration required if no out-of-band encoding
if (expectedEnc == SupportedEncoding.None)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.XmlDeclarationRequired)));
}
seg = new ArraySegment<byte>(ValidatingUTF8.GetBytes(GetEncoding(declEnc).GetChars(buffer, offset, count)));
return seg;
}
catch (DecoderFallbackException e)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.XmlInvalidBytes), e));
}
}
static void ThrowExpectedEncodingMismatch(SupportedEncoding expEnc, SupportedEncoding actualEnc)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.XmlExpectedEncoding, GetEncodingName(expEnc), GetEncodingName(actualEnc))));
}
static void ThrowEncodingMismatch(string declEnc, SupportedEncoding enc)
{
ThrowEncodingMismatch(declEnc, GetEncodingName(enc));
}
static void ThrowEncodingMismatch(string declEnc, string docEnc)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.XmlEncodingMismatch, declEnc, docEnc)));
}
// This stream wrapper does not support duplex
public override bool CanRead
{
get
{
if (!isReading)
return false;
return this.stream.CanRead;
}
}
// The encoding conversion and buffering breaks seeking.
public override bool CanSeek
{
get
{
return false;
}
}
// This stream wrapper does not support duplex
public override bool CanWrite
{
get
{
if (isReading)
return false;
return this.stream.CanWrite;
}
}
// The encoding conversion and buffering breaks seeking.
public override long Position
{
get
{
#pragma warning suppress 56503 // The contract for non seekable stream is to throw exception
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException());
}
set
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException());
}
}
public override void Close()
{
Flush();
base.Close();
this.stream.Close();
}
public override void Flush()
{
this.stream.Flush();
}
public override int ReadByte()
{
if (byteCount == 0 && encodingCode == SupportedEncoding.UTF8)
return this.stream.ReadByte();
if (Read(byteBuffer, 0, 1) == 0)
return -1;
return byteBuffer[0];
}
public override int Read(byte[] buffer, int offset, int count)
{
try
{
if (byteCount == 0)
{
if (encodingCode == SupportedEncoding.UTF8)
return this.stream.Read(buffer, offset, count);
// No more bytes than can be turned into characters
byteOffset = 0;
byteCount = this.stream.Read(bytes, byteCount, (chars.Length - 1) * 2);
// Check for end of stream
if (byteCount == 0)
return 0;
// Fix up incomplete chars
CleanupCharBreak();
// Change encoding
int charCount = this.encoding.GetChars(bytes, 0, byteCount, chars, 0);
byteCount = Encoding.UTF8.GetBytes(chars, 0, charCount, bytes, 0);
}
// Give them bytes
if (byteCount < count)
count = byteCount;
Buffer.BlockCopy(bytes, byteOffset, buffer, offset, count);
byteOffset += count;
byteCount -= count;
return count;
}
catch (DecoderFallbackException ex)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.XmlInvalidBytes), ex));
}
}
void CleanupCharBreak()
{
int max = byteOffset + byteCount;
// Read on 2 byte boundaries
if ((byteCount % 2) != 0)
{
int b = this.stream.ReadByte();
if (b < 0)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.UnexpectedEndOfFile)));
bytes[max++] = (byte)b;
byteCount++;
}
// Don't cut off a surrogate character
int w;
if (encodingCode == SupportedEncoding.UTF16LE)
{
w = bytes[max - 2] + (bytes[max - 1] << 8);
}
else
{
w = bytes[max - 1] + (bytes[max - 2] << 8);
}
if ((w & 0xDC00) != 0xDC00 && w >= 0xD800 && w <= 0xDBFF) // First 16-bit number of surrogate pair
{
int b1 = this.stream.ReadByte();
int b2 = this.stream.ReadByte();
if (b2 < 0)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.UnexpectedEndOfFile)));
bytes[max++] = (byte)b1;
bytes[max++] = (byte)b2;
byteCount += 2;
}
}
public override long Seek(long offset, SeekOrigin origin)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException());
}
public override void WriteByte(byte b)
{
if (encodingCode == SupportedEncoding.UTF8)
{
this.stream.WriteByte(b);
return;
}
byteBuffer[0] = b;
Write(byteBuffer, 0, 1);
}
public override void Write(byte[] buffer, int offset, int count)
{
// Optimize UTF-8 case
if (encodingCode == SupportedEncoding.UTF8)
{
this.stream.Write(buffer, offset, count);
return;
}
while (count > 0)
{
int size = chars.Length < count ? chars.Length : count;
int charCount = dec.GetChars(buffer, offset, size, chars, 0, false);
byteCount = enc.GetBytes(chars, 0, charCount, bytes, 0, false);
this.stream.Write(bytes, 0, byteCount);
offset += size;
count -= size;
}
}
// Delegate properties
public override bool CanTimeout { get { return this.stream.CanTimeout; } }
public override long Length { get { return this.stream.Length; } }
public override int ReadTimeout
{
get { return this.stream.ReadTimeout; }
set { this.stream.ReadTimeout = value; }
}
public override int WriteTimeout
{
get { return this.stream.WriteTimeout; }
set { this.stream.WriteTimeout = value; }
}
// Delegate methods
public override void SetLength(long value)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException());
}
}
// Add format exceptions
// Do we need to modify the stream position/Seek to account for the buffer?
// ASSUMPTION (Microsoft): This class will only be used for EITHER reading OR writing.
#if NO
class UTF16Stream : Stream
{
const int BufferLength = 128;
Stream stream;
bool bigEndian;
byte[] streamBuffer;
int streamOffset;
int streamMax;
byte[] trailBytes = new byte[4];
int trailCount;
public UTF16Stream(Stream stream, bool bigEndian)
{
this.stream = stream;
this.bigEndian = bigEndian;
this.streamBuffer = byte[BufferLength];
}
public override void Close()
{
Flush();
base.Close();
this.stream.Close();
}
public override void Flush()
{
this.stream.Flush();
}
public override int Read(byte[] buffer, int offset, int count)
{
// Validate args
// Read what we can if we aren't sure we have enough for a single character
if (this.streamMax < 4)
this.streamMax += this.stream.Read(this.streamBuffer, streamOffset, streamBuffer.Length - this.streamMax);
int totalWritten = 0;
while (streamOffset < streamMax && count > 0)
{
int ch;
int read;
read = ReadUTF16Char(out ch, streamBuffer, streamOffset, streamBuffer.Length - streamMax);
if (read == 0)
break;
int written = WriteUTF8Char(ch, buffer, offset, count);
if (written == 0)
break;
totalWritten += written;
streamOffset += read;
offset += written;
count -= written;
}
// Shift down the leftover data
if (this.streamOffset > 0 && this.streamOffset < this.streamMax)
{
Buffer.BlockCopy(this.streamBuffer, this.streamOffset, this.streamBuffer, 0, this.streamMax - this.streamOffset);
this.streamMax -= this.streamOffset;
this.streamOffset = 0;
}
return totalWritten;
}
int ReadUTF8Char(out int ch, byte[] buffer, int offset, int count)
{
ch = -1;
if (buffer[offset] < 0x80)
{
ch = buffer[offset];
return 1;
}
int mask = buffer[offset] & 0xF0;
byte b1, b2, b3, b4;
if (mask == 0xC0)
{
if (count < 2)
return 0;
b1 = buffer[offset + 0];
b2 = buffer[offset + 1];
ch = ((b1 & 0x1F) << 6) + (b2 & 0x3F);
return 2;
}
else if (mask == 0xE0)
{
if (count < 3)
return 0;
b1 = buffer[offset + 0];
b2 = buffer[offset + 1];
b3 = buffer[offset + 2];
ch = ((((b1 & 0x0F) << 6) + (b2 & 0x3F)) << 6) + (b3 & 0x3F);
return 3;
}
else if (mask == 0xF0)
{
if (count < 4)
return 0;
b1 = buffer[offset + 0];
b2 = buffer[offset + 1];
b3 = buffer[offset + 2];
b4 = buffer[offset + 3];
ch = ((((((b1 & 0x0F) << 6) + (b2 & 0x3F)) << 6) + (b3 & 0x3F)) << 6) + (b4 & 0x3F);
return 4;
}
// Invalid
return 0;
}
int ReadUTF16Char(out int ch, byte[] buffer, int offset, int count)
{
ch = -1;
if (count < 2)
return 0;
int w1 = ReadEndian(buffer, offset);
if (w1 < 0xD800 || w1 > 0xDFFF)
{
ch = w1;
return 2;
}
if (count < 4)
return 0;
int w2 = ReadEndian(buffer, offset + 2);
ch = ((w1 & 0x03FF) << 10) + (w2 & 0x03FF);
return 4;
}
int ReadEndian(byte[] buffer, int offset)
{
if (bigEndian)
{
return (buffer[offset + 0] << 8) + buffer[offset + 1];
}
else
{
return (buffer[offset + 1] << 8) + buffer[offset + 0];
}
}
int WriteUTF8Char(int ch, byte[] buffer, int offset, int count)
{
if (ch < 0x80)
{
buffer[offset] = (byte)ch;
return 1;
}
else if (ch < 0x800)
{
if (count < 2)
return 0;
buffer[offset + 1] = 0x80 | (ch & 0x3F);
ch >>= 6;
buffer[offset + 0] = 0xC0 | ch;
return 2
}
else if (ch < 0x10000)
{
if (count < 3)
return 0;
buffer[offset + 2] = 0x80 | (ch & 0x3F);
ch >>= 6;
buffer[offset + 1] = 0x80 | (ch & 0x3F);
ch >>= 6;
buffer[offset + 0] = 0xE0 | ch;
return 3;
}
else if (ch <= 0x110000)
{
if (count < 4)
return 0;
buffer[offset + 3] = 0x80 | (ch & 0x3F);
ch >>= 6;
buffer[offset + 2] = 0x80 | (ch & 0x3F);
ch >>= 6;
buffer[offset + 1] = 0x80 | (ch & 0x3F);
ch >>= 6;
buffer[offset + 0] = 0xF0 | ch;
return 4;
}
// Invalid?
return 0;
}
int WriteUTF16Char(int ch, byte[] buffer, int offset, int count)
{
if (ch < 0x10000)
{
if (count < 2)
return 0;
WriteEndian(ch, buffer, offset);
return 2;
}
if (count < 4)
return 0;
ch -= 0x10000;
int w2 = 0xDC00 | (ch & 0x03FF);
int w1 = 0xD800 | ch >> 10;
WriteEndian(w1, buffer, offset);
WriteEndian(w2, buffer, offset + 2);
return 4;
}
void WriteEndian(int ch, byte[] buffer, int offset)
{
if (bigEndian)
{
buffer[offset + 1] = (byte)ch;
buffer[offset + 0] = ch >> 8;
}
else
{
buffer[offset + 0] = (byte)ch;
buffer[offset + 1] = ch >> 8;
}
}
public override void Write(byte[] buffer, int offset, int count)
{
// Validate args
// Write the trail bytes
if (trailCount > 0)
{
int free = 4-trailCount;
int total = (count < free ? count : free) + trialCount;
Buffer.BlockCopy(buffer, offset, trailBytes, trailCount, total);
int c;
int r = ReadUTF8Char(out c, trailBuffer, 0, total);
if (r == 0 && count < free)
{
trailCount = total;
return;
}
int diff = r - trailCount;
offset += diff;
count -= diff;
streamOffset = WriteUTF16Char(c, streamBuffer, 0, streamBuffer.Length - streamOffset);
}
while (count > 0)
{
if (streamBuffer.Length - streamOffset < 4)
{
this.stream.Write(streamBuffer, 0, streamOffset);
streamOffset = 0;
}
int ch;
int read = ReadUTF8Char(out ch, buffer, offset, count);
if (read == 0)
break;
int written = WriteUTF16Char(ch, streamBuffer, streamOffset, streamBuffer.Length - streamOffset);
if (written == 0)
break;
streamOffset += written;
offset += read;
count -= read;
}
if (streamOffset > 0)
{
this.stream.Write(streamBuffer, 0, streamOffset);
streamOffset = 0;
}
// Save trailing bytes
if (count > 0)
{
Buffer.BlockCopy(buffer, offset, trailBytes, 0, count);
trailCount = count;
}
}
// Delegate properties
public override bool CanRead { get { return this.stream.CanRead; } }
public override bool CanSeek { get { return this.stream.CanSeek; } }
public override bool CanTimeout { get { return this.stream.CanTimeout; } }
public override bool CanWrite { get { return this.stream.CanWrite; } }
public override long Length { get { return this.stream.Length; } }
public override long Position
{
get { return this.stream.Position; }
set { this.stream.Position = value; }
}
public override int ReadTimeout
{
get { return this.stream.ReadTimeout; }
set { this.stream.ReadTimeout = value; }
}
public override int WriteTimeout
{
get { return this.stream.WriteTimeout; }
set { this.stream.WriteTimeout = value; }
}
// Delegate methods
public override long Seek(long offset, SeekOrigin origin)
{
return this.stream.Seek(offset, origin);
}
public override void SetLength(long value)
{
this.stream.SetLength(value);
}
}
#endif
}
|