|
static private CreateInvalidSurrogatePairException ( char low, char hi ) : |
||
| low | char | |
| hi | char | |
| return | ||
private static unsafe byte *EncodeSurrogate(char *pSrc, char *pSrcEnd, byte *pDst)
{
int highChar = pSrc[0];
if (highChar > 0xdbff)
{
throw XmlConvert.CreateInvalidHighSurrogateCharException((char)highChar);
}
if ((pSrc + 1) >= pSrcEnd)
{
throw new ArgumentException(Res.GetString("Xml_InvalidSurrogateMissingLowChar"));
}
int lowChar = pSrc[1];
if (lowChar < 0xdc00)
{
throw XmlConvert.CreateInvalidSurrogatePairException((char)lowChar, (char)highChar);
}
highChar = XmlCharType.CombineSurrogateChar(lowChar, highChar);
pDst[0] = (byte)(240 | (highChar >> 0x12));
pDst[1] = (byte)(0x80 | ((highChar >> 12) & 0x3f));
pDst[2] = (byte)(0x80 | ((highChar >> 6) & 0x3f));
pDst[3] = (byte)(0x80 | (highChar & 0x3f));
pDst += 4;
return(pDst);
}
public override bool Fallback(char charUnknownHigh, char charUnknownLow, int index)
{
// check input surrogate pair
if (!char.IsSurrogatePair(charUnknownHigh, charUnknownLow))
{
throw XmlConvert.CreateInvalidSurrogatePairException(charUnknownHigh, charUnknownLow);
}
// If we are already in fallback, throw, it's probably at the suspect character in charEntity
if (_charEntityIndex >= 0)
{
(new EncoderExceptionFallback()).CreateFallbackBuffer().Fallback(charUnknownHigh, charUnknownLow, index);
}
if (_parent.CanReplaceAt(index))
{
// Create the replacement character entity
_charEntity = string.Format(CultureInfo.InvariantCulture, "&#x{0:X};", new object[] { SurrogateCharToUtf32(charUnknownHigh, charUnknownLow) });
_charEntityIndex = 0;
return(true);
}
else
{
EncoderFallbackBuffer errorFallbackBuffer = (new EncoderExceptionFallback()).CreateFallbackBuffer();
errorFallbackBuffer.Fallback(charUnknownHigh, charUnknownLow, index);
return(false);
}
}
public override async Task WriteSurrogateCharEntityAsync(char lowChar, char highChar)
{
try
{
if (!Char.IsSurrogatePair(highChar, lowChar))
{
throw XmlConvert.CreateInvalidSurrogatePairException(lowChar, highChar);
}
await AdvanceStateAsync(Token.Text).ConfigureAwait(false);
if (SaveAttrValue)
{
_attrValueCache.WriteSurrogateCharEntity(lowChar, highChar);
}
else
{
await _writer.WriteSurrogateCharEntityAsync(lowChar, highChar).ConfigureAwait(false);
}
}
catch
{
_currentState = State.Error;
throw;
}
}
internal void WriteRawWithSurrogateChecking(string text)
{
if (text == null)
{
return;
}
if (cacheAttrValue)
{
attrValue.Append(text);
}
int len = text.Length;
int i = 0;
char ch = (char)0;
for (;;)
{
unsafe {
while (i < len &&
((xmlCharType.charProperties[ch = text[i]] & XmlCharType.fCharData) != 0 || // ( xmlCharType.IsCharData( ( ch = text[i] ) )
ch < 0x20))
{
i++;
}
}
if (i == len)
{
break;
}
if (XmlCharType.IsHighSurrogate(ch))
{
if (i + 1 < len)
{
char lowChar = text[i + 1];
if (XmlCharType.IsLowSurrogate(lowChar))
{
i += 2;
continue;
}
else
{
throw XmlConvert.CreateInvalidSurrogatePairException(lowChar, ch);
}
}
throw new ArgumentException(Res.GetString(Res.Xml_InvalidSurrogateMissingLowChar));
}
else if (XmlCharType.IsLowSurrogate(ch))
{
throw XmlConvert.CreateInvalidHighSurrogateCharException(ch);
}
else
{
i++;
}
}
textWriter.Write(text);
return;
}
internal void WriteRawWithSurrogateChecking(string text)
{
if (text == null)
{
return;
}
if (_cacheAttrValue)
{
_attrValue.Append(text);
}
int len = text.Length;
int i = 0;
char ch = (char)0;
while (true)
{
unsafe
{
while (i < len && (_xmlCharType.IsCharData((ch = text[i])) || ch < 0x20))
{
i++;
}
}
if (i == len)
{
break;
}
if (XmlCharType.IsHighSurrogate(ch))
{
if (i + 1 < len)
{
char lowChar = text[i + 1];
if (XmlCharType.IsLowSurrogate(lowChar))
{
i += 2;
continue;
}
else
{
throw XmlConvert.CreateInvalidSurrogatePairException(lowChar, ch);
}
}
throw new ArgumentException(SR.Xml_InvalidSurrogateMissingLowChar);
}
else if (XmlCharType.IsLowSurrogate(ch))
{
throw XmlConvert.CreateInvalidHighSurrogateCharException(ch);
}
else
{
i++;
}
}
_textWriter.Write(text);
return;
}
internal void WriteSurrogateChar(char lowChar, char highChar)
{
if (!XmlCharType.IsLowSurrogate(lowChar) || !XmlCharType.IsHighSurrogate(highChar))
{
throw XmlConvert.CreateInvalidSurrogatePairException(lowChar, highChar);
}
this.textWriter.Write(highChar);
this.textWriter.Write(lowChar);
}
internal void WriteSurrogateChar(char lowChar, char highChar)
{
if (((int)lowChar < SurLowStart || (int)lowChar > SurLowEnd) ||
((int)highChar < SurHighStart || (int)highChar > SurHighEnd))
{
throw XmlConvert.CreateInvalidSurrogatePairException(lowChar, highChar);
}
textWriter.Write(highChar);
textWriter.Write(lowChar);
}
internal void WriteSurrogateCharEntity(char lowChar, char highChar)
{
if (!XmlCharType.IsLowSurrogate(lowChar) || !XmlCharType.IsHighSurrogate(highChar))
{
throw XmlConvert.CreateInvalidSurrogatePairException(lowChar, highChar);
}
int num = XmlCharType.CombineSurrogateChar(lowChar, highChar);
if (this.cacheAttrValue)
{
this.attrValue.Append(highChar);
this.attrValue.Append(lowChar);
}
this.textWriter.Write("&#x");
this.textWriter.Write(num.ToString("X", NumberFormatInfo.InvariantInfo));
this.textWriter.Write(';');
}
internal unsafe void WriteRawWithSurrogateChecking(string text)
{
if (text == null)
{
return;
}
if (this.cacheAttrValue)
{
this.attrValue.Append(text);
}
int length = text.Length;
int num2 = 0;
char ch = '\0';
Label_002A:
while ((num2 < length) && (((this.xmlCharType.charProperties[ch = text[num2]] & 0x10) != 0) || (ch < ' ')))
{
num2++;
}
if (num2 != length)
{
if (XmlCharType.IsHighSurrogate(ch))
{
if ((num2 + 1) >= length)
{
throw new ArgumentException(Res.GetString("Xml_InvalidSurrogateMissingLowChar"));
}
char ch2 = text[num2 + 1];
if (!XmlCharType.IsLowSurrogate(ch2))
{
throw XmlConvert.CreateInvalidSurrogatePairException(ch2, ch);
}
num2 += 2;
}
else
{
if (XmlCharType.IsLowSurrogate(ch))
{
throw XmlConvert.CreateInvalidHighSurrogateCharException(ch);
}
num2++;
}
goto Label_002A;
}
this.textWriter.Write(text);
}
public override bool Fallback(char charUnknownHigh, char charUnknownLow, int index)
{
if (!char.IsSurrogatePair(charUnknownHigh, charUnknownLow))
{
throw XmlConvert.CreateInvalidSurrogatePairException(charUnknownHigh, charUnknownLow);
}
if (this.charEntityIndex >= 0)
{
new EncoderExceptionFallback().CreateFallbackBuffer().Fallback(charUnknownHigh, charUnknownLow, index);
}
if (this.parent.CanReplaceAt(index))
{
this.charEntity = string.Format(CultureInfo.InvariantCulture, "&#x{0:X};", new object[] { this.SurrogateCharToUtf32(charUnknownHigh, charUnknownLow) });
this.charEntityIndex = 0;
return(true);
}
new EncoderExceptionFallback().CreateFallbackBuffer().Fallback(charUnknownHigh, charUnknownLow, index);
return(false);
}
internal void WriteSurrogateCharEntity(char lowChar, char highChar)
{
if (((int)lowChar < SurLowStart || (int)lowChar > SurLowEnd) ||
((int)highChar < SurHighStart || (int)highChar > SurHighEnd))
{
throw XmlConvert.CreateInvalidSurrogatePairException(lowChar, highChar);
}
int surrogateChar = ((int)lowChar - SurLowStart) | (((int)highChar - SurHighStart) << 10) + 0x10000;
if (cacheAttrValue)
{
attrValue.Append(highChar);
attrValue.Append(lowChar);
}
textWriter.Write("&#x");
textWriter.Write(surrogateChar.ToString("X", NumberFormatInfo.InvariantInfo));
textWriter.Write(';');
}
internal void WriteSurrogateCharEntity(char lowChar, char highChar)
{
if (!XmlCharType.IsLowSurrogate(lowChar) ||
!XmlCharType.IsHighSurrogate(highChar))
{
throw XmlConvert.CreateInvalidSurrogatePairException(lowChar, highChar);
}
int surrogateChar = XmlCharType.CombineSurrogateChar(lowChar, highChar);
if (_cacheAttrValue)
{
Debug.Assert(_attrValue != null);
_attrValue.Append(highChar);
_attrValue.Append(lowChar);
}
_textWriter.Write("&#x");
_textWriter.Write(surrogateChar.ToString("X", NumberFormatInfo.InvariantInfo));
_textWriter.Write(';');
}
internal void Write(string text)
{
if (text == null)
{
return;
}
if (_cacheAttrValue)
{
_attrValue.Append(text);
}
// scan through the string to see if there are any characters to be escaped
int len = text.Length;
int i = 0;
int startPos = 0;
char ch = (char)0;
while (true)
{
while (i < len && _xmlCharType.IsAttributeValueChar(ch = text[i]))
{
i++;
}
if (i == len)
{
// reached the end of the string -> write it whole out
_textWriter.Write(text);
return;
}
if (_inAttribute)
{
if (ch == 0x9)
{
i++;
continue;
}
}
else
{
if (ch == 0x9 || ch == 0xA || ch == 0xD || ch == '"' || ch == '\'')
{
i++;
continue;
}
}
// some character that needs to be escaped is found:
break;
}
char[] helperBuffer = new char[256];
while (true)
{
if (startPos < i)
{
WriteStringFragment(text, startPos, i - startPos, helperBuffer);
}
if (i == len)
{
break;
}
switch (ch)
{
case (char)0x9:
_textWriter.Write(ch);
break;
case (char)0xA:
case (char)0xD:
if (_inAttribute)
{
WriteCharEntityImpl(ch);
}
else
{
_textWriter.Write(ch);
}
break;
case '<':
WriteEntityRefImpl("lt");
break;
case '>':
WriteEntityRefImpl("gt");
break;
case '&':
WriteEntityRefImpl("amp");
break;
case '\'':
if (_inAttribute && _quoteChar == ch)
{
WriteEntityRefImpl("apos");
}
else
{
_textWriter.Write('\'');
}
break;
case '"':
if (_inAttribute && _quoteChar == ch)
{
WriteEntityRefImpl("quot");
}
else
{
_textWriter.Write('"');
}
break;
default:
if (XmlCharType.IsHighSurrogate(ch))
{
if (i + 1 < len)
{
WriteSurrogateChar(text[++i], ch);
}
else
{
throw XmlConvert.CreateInvalidSurrogatePairException(text[i], ch);
}
}
else if (XmlCharType.IsLowSurrogate(ch))
{
throw XmlConvert.CreateInvalidHighSurrogateCharException(ch);
}
else
{
Debug.Assert((ch < 0x20 && !_xmlCharType.IsWhiteSpace(ch)) || (ch > 0xFFFD));
WriteCharEntityImpl(ch);
}
break;
}
i++;
startPos = i;
while (i < len && _xmlCharType.IsAttributeValueChar(ch = text[i]))
{
i++;
}
}
}
internal unsafe void Write(string text)
{
char[] chArray;
if (text == null)
{
return;
}
if (this.cacheAttrValue)
{
this.attrValue.Append(text);
}
int length = text.Length;
int num2 = 0;
int offset = 0;
char ch = '\0';
Label_002C:
while ((num2 < length) && ((this.xmlCharType.charProperties[ch = text[num2]] & 0x80) != 0))
{
num2++;
}
if (num2 == length)
{
this.textWriter.Write(text);
return;
}
if (this.inAttribute)
{
if (ch != '\t')
{
goto Label_0091;
}
num2++;
goto Label_002C;
}
if (((ch == '\t') || (ch == '\n')) || (((ch == '\r') || (ch == '"')) || (ch == '\'')))
{
num2++;
goto Label_002C;
}
Label_0091:
chArray = new char[0x100];
while (true)
{
if (offset < num2)
{
this.WriteStringFragment(text, offset, num2 - offset, chArray);
}
if (num2 == length)
{
return;
}
switch (ch)
{
case '\t':
this.textWriter.Write(ch);
break;
case '\n':
case '\r':
if (!this.inAttribute)
{
this.textWriter.Write(ch);
}
else
{
this.WriteCharEntityImpl(ch);
}
break;
case '"':
if (this.inAttribute && (this.quoteChar == ch))
{
this.WriteEntityRefImpl("quot");
}
else
{
this.textWriter.Write('"');
}
break;
case '&':
this.WriteEntityRefImpl("amp");
break;
case '\'':
if (!this.inAttribute || (this.quoteChar != ch))
{
this.textWriter.Write('\'');
}
else
{
this.WriteEntityRefImpl("apos");
}
break;
case '<':
this.WriteEntityRefImpl("lt");
break;
case '>':
this.WriteEntityRefImpl("gt");
break;
default:
if (XmlCharType.IsHighSurrogate(ch))
{
if ((num2 + 1) >= length)
{
throw XmlConvert.CreateInvalidSurrogatePairException(text[num2], ch);
}
this.WriteSurrogateChar(text[++num2], ch);
}
else
{
if (XmlCharType.IsLowSurrogate(ch))
{
throw XmlConvert.CreateInvalidHighSurrogateCharException(ch);
}
this.WriteCharEntityImpl(ch);
}
break;
}
num2++;
offset = num2;
while ((num2 < length) && ((this.xmlCharType.charProperties[ch = text[num2]] & 0x80) != 0))
{
num2++;
}
}
}