| public abstract Fallback ( char charUnknownHigh, char charUnknownLow, int index ) : bool | ||
| charUnknownHigh | char | |
| charUnknownLow | char | |
| index | int | |
| return | bool | |
public void HandleFallback(ref EncoderFallbackBuffer buffer,
char[] chars, ref int charIndex, ref int charCount,
byte[] bytes, ref int byteIndex, ref int byteCount, object state)
{
if (buffer == null)
buffer = EncoderFallback.CreateFallbackBuffer();
// THIS IS WERE THE BUG IS!! (pruiz)
if (charCount > 1 && (Char.IsSurrogate(chars[charIndex]) && Char.IsSurrogate(chars[charIndex + 1])))
{
buffer.Fallback (chars[charIndex], chars[charIndex + 1], charIndex);
charIndex++;
charCount--;
}
else
buffer.Fallback (chars[charIndex], charIndex);
char[] tmp = new char[buffer.Remaining];
int idx = 0;
while (buffer.Remaining > 0)
tmp[idx++] = buffer.GetNextChar();
var len = state == null ?
GetBytes(tmp, 0, tmp.Length, bytes, byteIndex)
: GetBytesInternal(tmp, 0, tmp.Length, bytes, byteIndex, true, state);
byteIndex += len;
byteCount -= len;
}
public unsafe void HandleFallback (ref EncoderFallbackBuffer buffer,
char* chars, ref int charIndex, ref int charCount,
byte* bytes, ref int byteIndex, ref int byteCount, object state)
{
if (buffer == null)
buffer = EncoderFallback.CreateFallbackBuffer ();
if (charCount > 1 && (Char.IsSurrogate (chars [charIndex]) && Char.IsSurrogate (chars [charIndex + 1]))) {
buffer.Fallback (chars [charIndex], chars [charIndex + 1], charIndex);
charIndex++;
charCount--;
}
else
buffer.Fallback (chars [charIndex], charIndex);
char [] tmp = new char [buffer.Remaining];
int idx = 0;
while (buffer.Remaining > 0)
tmp [idx++] = buffer.GetNextChar ();
fixed (char* tmparr = tmp) {
var outbytes = bytes == null ? null : bytes + byteIndex;
var len = state == null ?
GetBytes(tmparr, tmp.Length, outbytes, byteCount)
: GetBytesInternal(tmparr, tmp.Length, outbytes, byteCount, true, state);
byteIndex += len;
byteCount -= len;
}
}
public unsafe void HandleFallback (ref EncoderFallbackBuffer buffer,
char* chars, ref int charIndex, ref int charCount,
byte* bytes, ref int byteIndex, ref int byteCount)
{
if (buffer == null)
buffer = EncoderFallback.CreateFallbackBuffer ();
if (Char.IsSurrogate (chars [charIndex]) && charCount > 0 &&
Char.IsSurrogate (chars [charIndex + 1])) {
buffer.Fallback (chars [charIndex], chars [charIndex + 1], charIndex);
charIndex++;
charCount--;
}
else
buffer.Fallback (chars [charIndex], charIndex);
char [] tmp = new char [buffer.Remaining];
int idx = 0;
while (buffer.Remaining > 0)
tmp [idx++] = buffer.GetNextChar ();
fixed (char* tmparr = tmp) {
byteIndex += GetBytes (tmparr, tmp.Length, bytes + byteIndex, byteCount);
}
}
unsafe static char [] GetFallbackChars(char *chars, char *start, EncoderFallback fallback, ref EncoderFallbackBuffer buffer)
{
if (buffer == null)
{
buffer = fallback.CreateFallbackBuffer();
}
buffer.Fallback(*chars, (int)(chars - start));
char [] fallback_chars = new char [buffer.Remaining];
for (int i = 0; i < fallback_chars.Length; i++)
{
fallback_chars [i] = buffer.GetNextChar();
}
buffer.Reset();
return(fallback_chars);
}
unsafe int InternalGetBytes(char *chars, int charLength, int charIndex, int charCount,
byte[] bytes, int byteIndex,
ref EncoderFallbackBuffer buffer,
ref char [] fallback_chars)
{
if (bytes == null)
{
throw new ArgumentNullException("bytes");
}
if (charIndex < 0 || charIndex > charLength)
{
throw new ArgumentOutOfRangeException("charIndex", _("ArgRange_StringIndex"));
}
if (charCount < 0 || charCount > (charLength - charIndex))
{
throw new ArgumentOutOfRangeException("charCount", _("ArgRange_StringRange"));
}
if (byteIndex < 0 || byteIndex > bytes.Length)
{
throw new ArgumentOutOfRangeException("byteIndex", _("ArgRange_Array"));
}
if ((bytes.Length - byteIndex) < charCount)
{
throw new ArgumentException(_("Arg_InsufficientSpace"));
}
int count = charCount;
char ch;
while (count-- > 0)
{
ch = chars [charIndex++];
if (ch < (char)0x80)
{
bytes [byteIndex++] = (byte)ch;
}
else
{
if (buffer == null)
{
buffer = EncoderFallback.CreateFallbackBuffer();
}
if (Char.IsSurrogate(ch) && count > 1 &&
Char.IsSurrogate(chars [charIndex]))
{
buffer.Fallback(ch, chars [charIndex], charIndex++ - 1);
}
else
{
buffer.Fallback(ch, charIndex - 1);
}
if (fallback_chars == null || fallback_chars.Length < buffer.Remaining)
{
fallback_chars = new char [buffer.Remaining];
}
for (int i = 0; i < fallback_chars.Length; i++)
{
fallback_chars [i] = buffer.GetNextChar();
}
byteIndex += GetBytes(fallback_chars, 0,
fallback_chars.Length, bytes, byteIndex,
ref buffer, ref fallback_chars);
}
}
return(charCount);
}
unsafe static char [] GetFallbackChars (char *chars, char *start, EncoderFallback fallback, ref EncoderFallbackBuffer buffer)
{
if (buffer == null)
buffer = fallback.CreateFallbackBuffer ();
buffer.Fallback (*chars, (int) (chars - start));
char [] fallback_chars = new char [buffer.Remaining];
for (int i = 0; i < fallback_chars.Length; i++)
fallback_chars [i] = buffer.GetNextChar ();
buffer.Reset ();
return fallback_chars;
}
unsafe int InternalGetBytes (char *chars, int charLength, int charIndex, int charCount,
byte[] bytes, int byteIndex,
ref EncoderFallbackBuffer buffer,
ref char [] fallback_chars)
{
if (bytes == null)
throw new ArgumentNullException ("bytes");
if (charIndex < 0 || charIndex > charLength)
throw new ArgumentOutOfRangeException ("charIndex", _("ArgRange_StringIndex"));
if (charCount < 0 || charCount > (charLength - charIndex))
throw new ArgumentOutOfRangeException ("charCount", _("ArgRange_StringRange"));
if (byteIndex < 0 || byteIndex > bytes.Length)
throw new ArgumentOutOfRangeException ("byteIndex", _("ArgRange_Array"));
if ((bytes.Length - byteIndex) < charCount)
throw new ArgumentException (_("Arg_InsufficientSpace"));
int count = charCount;
char ch;
while (count-- > 0) {
ch = chars [charIndex++];
if (ch < (char)0x80) {
bytes [byteIndex++] = (byte)ch;
} else {
if (buffer == null)
buffer = EncoderFallback.CreateFallbackBuffer ();
if (Char.IsSurrogate (ch) && count > 1 &&
Char.IsSurrogate (chars [charIndex]))
buffer.Fallback (ch, chars [charIndex], charIndex++ - 1);
else
buffer.Fallback (ch, charIndex - 1);
if (fallback_chars == null || fallback_chars.Length < buffer.Remaining)
fallback_chars = new char [buffer.Remaining];
for (int i = 0; i < fallback_chars.Length; i++)
fallback_chars [i] = buffer.GetNextChar ();
byteIndex += GetBytes (fallback_chars, 0,
fallback_chars.Length, bytes, byteIndex,
ref buffer, ref fallback_chars);
}
}
return charCount;
}
int GetBytes(char[] chars, int charIndex, int charCount,
byte[] bytes, int byteIndex,
ref EncoderFallbackBuffer buffer,
ref char [] fallback_chars)
{
#endif
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"));
}
if ((bytes.Length - byteIndex) < charCount)
{
throw new ArgumentException(_("Arg_InsufficientSpace"));
}
int count = charCount;
char ch;
while (count-- > 0)
{
ch = chars [charIndex++];
if (ch < (char)0x0100)
{
bytes [byteIndex++] = (byte)ch;
}
else if (ch >= '\uFF01' && ch <= '\uFF5E')
{
bytes [byteIndex++] = (byte)(ch - 0xFEE0);
}
else
{
#if NET_2_0
if (buffer == null)
{
buffer = EncoderFallback.CreateFallbackBuffer();
}
if (Char.IsSurrogate(ch) && count > 1 &&
Char.IsSurrogate(chars [charIndex]))
{
buffer.Fallback(ch, chars [charIndex], charIndex++ - 1);
}
else
{
buffer.Fallback(ch, charIndex - 1);
}
if (fallback_chars == null || fallback_chars.Length < buffer.Remaining)
{
fallback_chars = new char [buffer.Remaining];
}
for (int i = 0; i < fallback_chars.Length; i++)
{
fallback_chars [i] = buffer.GetNextChar();
}
byteIndex += GetBytes(fallback_chars, 0,
fallback_chars.Length, bytes, byteIndex,
ref buffer, ref fallback_chars);
#else
bytes [byteIndex++] = (byte)'?';
#endif
}
}
return(charCount);
}
int GetBytes (char[] chars, int charIndex, int charCount,
byte[] bytes, int byteIndex,
ref EncoderFallbackBuffer buffer,
ref char [] fallback_chars)
{
#endif
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"));
}
if ((bytes.Length - byteIndex) < charCount) {
throw new ArgumentException (_("Arg_InsufficientSpace"));
}
int count = charCount;
char ch;
while (count-- > 0) {
ch = chars [charIndex++];
if (ch < (char)0x0100) {
bytes [byteIndex++] = (byte)ch;
} else if (ch >= '\uFF01' && ch <= '\uFF5E') {
bytes [byteIndex++] = (byte)(ch - 0xFEE0);
} else {
#if NET_2_0
if (buffer == null)
buffer = EncoderFallback.CreateFallbackBuffer ();
if (Char.IsSurrogate (ch) && count > 1 &&
Char.IsSurrogate (chars [charIndex]))
buffer.Fallback (ch, chars [charIndex], charIndex++ - 1);
else
buffer.Fallback (ch, charIndex - 1);
if (fallback_chars == null || fallback_chars.Length < buffer.Remaining)
fallback_chars = new char [buffer.Remaining];
for (int i = 0; i < fallback_chars.Length; i++)
fallback_chars [i] = buffer.GetNextChar ();
byteIndex += GetBytes (fallback_chars, 0,
fallback_chars.Length, bytes, byteIndex,
ref buffer, ref fallback_chars);
#else
bytes [byteIndex++] = (byte)'?';
#endif
}
}
return charCount;
}
private int GetBytes(string chars, int charIndex, int charCount, byte[] bytes, int byteIndex, ref EncoderFallbackBuffer buffer, ref char[] fallback_chars)
{
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_StringIndex"));
}
if (charCount < 0 || charCount > chars.Length - charIndex)
{
throw new ArgumentOutOfRangeException("charCount", Encoding._("ArgRange_StringRange"));
}
if (byteIndex < 0 || byteIndex > bytes.Length)
{
throw new ArgumentOutOfRangeException("byteIndex", Encoding._("ArgRange_Array"));
}
if (bytes.Length - byteIndex < charCount)
{
throw new ArgumentException(Encoding._("Arg_InsufficientSpace"));
}
int num = charCount;
while (num-- > 0)
{
char c = chars[charIndex++];
if (c < '\u0080')
{
bytes[byteIndex++] = (byte)c;
}
else
{
if (buffer == null)
{
buffer = base.EncoderFallback.CreateFallbackBuffer();
}
if (char.IsSurrogate(c) && num > 1 && char.IsSurrogate(chars[charIndex]))
{
buffer.Fallback(c, chars[charIndex], charIndex++ - 1);
}
else
{
buffer.Fallback(c, charIndex - 1);
}
if (fallback_chars == null || fallback_chars.Length < buffer.Remaining)
{
fallback_chars = new char[buffer.Remaining];
}
for (int i = 0; i < fallback_chars.Length; i++)
{
fallback_chars[i] = buffer.GetNextChar();
}
byteIndex += this.GetBytes(fallback_chars, 0, fallback_chars.Length, bytes, byteIndex, ref buffer, ref fallback_chars);
}
}
return(charCount);
}
// This function is called when we want to flush the decoder state
// (i.e. in case of invalid UTF-16 characters or dangling surrogates)
internal unsafe static EncoderStatus InternalGetBytesFlush (
byte* bytes, int byteCount,
EncoderFallbackBuffer fallbackBuffer,
int charsProcessed, ref int bytesProcessed,
ref uint leftChar)
{
int t_charsProcessed, t_bytesProcessed;
// in normal circumstances fallbackBuffer never is null, except
// when we have called InternalGetBytes from this function
// (for avoiding infinite recursive calls)
if (fallbackBuffer == null)
return EncoderStatus.Ok;
// if there is nothing to flush, then return silently
if(leftChar == 0)
return EncoderStatus.Ok;
// invalid UTF-16 or invalid surrogate
fallbackBuffer.Fallback ((char) leftChar, charsProcessed - 1);
// if we've arrived here we are working in replacement mode:
// build a replacement fallback_chars buffer
char[] fallback_chars = new char [fallbackBuffer.Remaining];
for (int i = 0; i < fallback_chars.Length; i++)
fallback_chars [i] = fallbackBuffer.GetNextChar ();
fallbackBuffer.Reset ();
// and encode it into UTF8 bytes...
fixed (char *fb_chars = fallback_chars) {
leftChar = 0;
switch (bytes != null
? InternalGetBytes (
fb_chars, fallback_chars.Length,
bytes + bytesProcessed, byteCount - bytesProcessed,
null, out t_charsProcessed, out t_bytesProcessed,
ref leftChar,
true)
: InternalGetBytes (
fb_chars, fallback_chars.Length,
null, byteCount,
null, out t_charsProcessed, out t_bytesProcessed,
ref leftChar,
true)) {
case EncoderStatus.Ok:
// everything OK :D
bytesProcessed += t_bytesProcessed;
break;
case EncoderStatus.InsufficientSpace:
return EncoderStatus.InsufficientSpace;
case EncoderStatus.InputRunOut:
case EncoderStatus.InvalidChar:
case EncoderStatus.InvalidSurrogate:
throw new ArgumentException ("Fallback chars are pure evil.", "fallback buffer bytes");
}
}
// flush encoder state
leftChar = 0;
return EncoderStatus.Ok;
}