static private BuildCharExceptionArgs ( char invChar, char nextChar ) : string[] | ||
invChar | char | |
nextChar | char | |
Результат | string[] |
private void CheckWhitespace(string value) { int invCharIndex = this.xmlCharType.IsOnlyWhitespaceWithPos(value); if (invCharIndex != -1) { this.Throw("Xml_InvalidWhitespaceCharacter", XmlException.BuildCharExceptionArgs(value, invCharIndex)); } }
private void CheckWhitespace(string value) { int i; if ((i = _xmlCharType.IsOnlyWhitespaceWithPos(value)) != -1) { Throw(SR.Xml_InvalidWhitespaceCharacter, XmlException.BuildCharExceptionArgs(value, i)); } }
protected void ValidateContentChars(string chars, string propertyName, bool allowOnlyWhitespace) { if (allowOnlyWhitespace) { if (!this.xmlCharType.IsOnlyWhitespace(chars)) { throw new ArgumentException(Res.GetString("Xml_IndentCharsNotWhitespace", new object[] { propertyName })); } return; } string str = null; for (int i = 0; i < chars.Length; i++) { if (this.xmlCharType.IsTextChar(chars[i])) { continue; } switch (chars[i]) { case '<': case ']': case '&': str = Res.GetString("Xml_InvalidCharacter", XmlException.BuildCharExceptionArgs(chars, i)); goto Label_0132; case '\t': case '\n': case '\r': { continue; } } if (XmlCharType.IsHighSurrogate(chars[i])) { if (((i + 1) < chars.Length) && XmlCharType.IsLowSurrogate(chars[i + 1])) { i++; continue; } str = Res.GetString("Xml_InvalidSurrogateMissingLowChar"); goto Label_0132; } if (XmlCharType.IsLowSurrogate(chars[i])) { object[] args = new object[] { ((uint)chars[i]).ToString("X", CultureInfo.InvariantCulture) }; str = Res.GetString("Xml_InvalidSurrogateHighChar", args); goto Label_0132; } } return; Label_0132 :; throw new ArgumentException(Res.GetString("Xml_InvalidCharsInIndent", new string[] { propertyName, str })); }
internal static void ThrowInvalidName(string s, int offsetStartChar, int offsetBadChar) { if (offsetStartChar >= s.Length) { throw new XmlException("Xml_EmptyName", string.Empty); } if (xmlCharType.IsNCNameSingleChar(s[offsetBadChar]) && !XmlCharType.Instance.IsStartNCNameSingleChar(s[offsetBadChar])) { throw new XmlException("Xml_BadStartNameChar", XmlException.BuildCharExceptionArgs(s, offsetBadChar)); } throw new XmlException("Xml_BadNameChar", XmlException.BuildCharExceptionArgs(s, offsetBadChar)); }
internal static Exception GetInvalidNameException(string s, int offsetStartChar, int offsetBadChar) { if (offsetStartChar >= s.Length) { return(new XmlException("Xml_EmptyName", string.Empty)); } if (xmlCharType.IsNCNameSingleChar(s[offsetBadChar]) && !xmlCharType.IsStartNCNameSingleChar(s[offsetBadChar])) { return(new XmlException("Xml_BadStartNameChar", XmlException.BuildCharExceptionArgs(s, offsetBadChar))); } return(new XmlException("Xml_BadNameChar", XmlException.BuildCharExceptionArgs(s, offsetBadChar))); }
private void ValidateQName(string name) { if (name.Length == 0) { throw new ArgumentException(SR.Xml_EmptyName); } int colonPos; int len = ValidateNames.ParseQName(name, 0, out colonPos); if (len != name.Length) { string res = (len == 0 || (colonPos > -1 && len == colonPos + 1)) ? SR.Xml_BadStartNameChar : SR.Xml_BadNameChar; throw new ArgumentException(string.Format(res, XmlException.BuildCharExceptionArgs(name, len))); } }
private void ValidateQName(string name) { int num; if (name.Length == 0) { throw new ArgumentException(Res.GetString("Xml_EmptyName")); } int invCharIndex = ValidateNames.ParseQName(name, 0, out num); if (invCharIndex != name.Length) { string str = ((invCharIndex == 0) || ((num > -1) && (invCharIndex == (num + 1)))) ? "Xml_BadStartNameChar" : "Xml_BadNameChar"; throw new ArgumentException(Res.GetString(str, XmlException.BuildCharExceptionArgs(name, invCharIndex))); } }
// Verification method for XML whitespace characters as defined in XML spec production [3] S. // Throws XmlException if invalid character is found, otherwise returns the input string. public static string VerifyWhitespace(string content) { if (content == null) { throw new ArgumentNullException("content"); } // returns the position of invalid character or -1 int pos = s_xmlCharType.IsOnlyWhitespaceWithPos(content); if (pos != -1) { throw new XmlException(SR.Xml_InvalidWhitespaceCharacter, XmlException.BuildCharExceptionArgs(content, pos), 0, pos + 1); } return(content); }
internal static string VerifyQName(string name, ExceptionType exceptionType) { if (name == null || name.Length == 0) { throw new ArgumentNullException("name"); } int colonPosition = -1; int endPos = ValidateNames.ParseQName(name, 0, out colonPosition); if (endPos != name.Length) { throw CreateException(SR.Xml_BadNameChar, XmlException.BuildCharExceptionArgs(name, endPos), exceptionType, 0, endPos + 1); } return(name); }
internal static string VerifyNMTOKEN(string name, ExceptionType exceptionType) { if (name == null) { throw new ArgumentNullException("name"); } if (name.Length == 0) { throw CreateException(SR.Xml_InvalidNmToken, name, exceptionType); } int endPos = ValidateNames.ParseNmtokenNoNamespaces(name, 0); if (endPos != name.Length) { throw CreateException(SR.Xml_BadNameChar, XmlException.BuildCharExceptionArgs(name, endPos), exceptionType, 0, endPos + 1); } return(name); }
/// <summary> /// Split a QualifiedName into prefix and localname, w/o any checking. /// (Used for XmlReader/XPathNavigator MoveTo(name) methods) /// </summary> internal static void SplitQName(string name, out string prefix, out string lname) { int colonPos = name.IndexOf(':'); if (-1 == colonPos) { prefix = string.Empty; lname = name; } else if (0 == colonPos || (name.Length - 1) == colonPos) { throw new ArgumentException(SR.Format(SR.Xml_BadNameChar, XmlException.BuildCharExceptionArgs(':', '\0')), nameof(name)); } else { prefix = name.Substring(0, colonPos); colonPos++; // move after colon lname = name.Substring(colonPos, name.Length - colonPos); } }
internal static void SplitQName(string name, out string prefix, out string lname) { int index = name.IndexOf(':'); if (-1 == index) { prefix = string.Empty; lname = name; } else { if ((index == 0) || ((name.Length - 1) == index)) { throw new ArgumentException(Res.GetString("Xml_BadNameChar", XmlException.BuildCharExceptionArgs(':', '\0')), "name"); } prefix = name.Substring(0, index); index++; lname = name.Substring(index, name.Length - index); } }
internal static Exception GetInvalidNameException(string s, int offsetStartChar, int offsetBadChar) { // If the name is empty, throw an exception if (offsetStartChar >= s.Length) { return(new XmlException(SR.Xml_EmptyName, string.Empty)); } Debug.Assert(offsetBadChar < s.Length); if (s_xmlCharType.IsNCNameSingleChar(s[offsetBadChar]) && !s_xmlCharType.IsStartNCNameSingleChar(s[offsetBadChar])) { // The error character is a valid name character, but is not a valid start name character return(new XmlException(SR.Xml_BadStartNameChar, XmlException.BuildCharExceptionArgs(s, offsetBadChar))); } else { // The error character is an invalid name character return(new XmlException(SR.Xml_BadNameChar, XmlException.BuildCharExceptionArgs(s, offsetBadChar))); } }
public override Task WriteWhitespaceAsync(string ws) { if (ws == null) { ws = string.Empty; } // "checkNames" is intentional here; if false, the whitespace is checked in XmlWellformedWriter if (_checkNames) { int i; if ((i = _xmlCharType.IsOnlyWhitespaceWithPos(ws)) != -1) { throw new ArgumentException(SR.Format(SR.Xml_InvalidWhitespaceCharacter, XmlException.BuildCharExceptionArgs(ws, i))); } } if (_replaceNewLines) { ws = ReplaceNewLines(ws); } return(writer.WriteWhitespaceAsync(ws)); }
public override void WriteWhitespace(string ws) { int num; if (ws == null) { ws = string.Empty; } if (this.checkNames && ((num = this.xmlCharType.IsOnlyWhitespaceWithPos(ws)) != -1)) { throw new ArgumentException(Res.GetString("Xml_InvalidWhitespaceCharacter", XmlException.BuildCharExceptionArgs(ws, num))); } if (this.replaceNewLines) { ws = this.ReplaceNewLines(ws); } base.writer.WriteWhitespace(ws); }
public override bool Read() { switch (_state) { case State.Initial: _state = State.Interactive; if (base.reader.ReadState == ReadState.Initial) { goto case State.Interactive; } break; case State.Error: return(false); case State.InReadBinary: FinishReadBinary(); _state = State.Interactive; goto case State.Interactive; case State.Interactive: if (!base.reader.Read()) { return(false); } break; default: Debug.Assert(false); return(false); } XmlNodeType nodeType = base.reader.NodeType; if (!_checkCharacters) { switch (nodeType) { case XmlNodeType.Comment: if (_ignoreComments) { return(Read()); } break; case XmlNodeType.Whitespace: if (_ignoreWhitespace) { return(Read()); } break; case XmlNodeType.ProcessingInstruction: if (_ignorePis) { return(Read()); } break; case XmlNodeType.DocumentType: if (_dtdProcessing == DtdProcessing.Prohibit) { Throw(SR.Xml_DtdIsProhibitedEx, string.Empty); } else if (_dtdProcessing == DtdProcessing.Ignore) { return(Read()); } break; } return(true); } else { switch (nodeType) { case XmlNodeType.Element: if (_checkCharacters) { // check element name ValidateQName(base.reader.Prefix, base.reader.LocalName); // check values of attributes if (base.reader.MoveToFirstAttribute()) { do { ValidateQName(base.reader.Prefix, base.reader.LocalName); CheckCharacters(base.reader.Value); } while (base.reader.MoveToNextAttribute()); base.reader.MoveToElement(); } } break; case XmlNodeType.Text: case XmlNodeType.CDATA: if (_checkCharacters) { CheckCharacters(base.reader.Value); } break; case XmlNodeType.EntityReference: if (_checkCharacters) { // check name ValidateQName(base.reader.Name); } break; case XmlNodeType.ProcessingInstruction: if (_ignorePis) { return(Read()); } if (_checkCharacters) { ValidateQName(base.reader.Name); CheckCharacters(base.reader.Value); } break; case XmlNodeType.Comment: if (_ignoreComments) { return(Read()); } if (_checkCharacters) { CheckCharacters(base.reader.Value); } break; case XmlNodeType.DocumentType: if (_dtdProcessing == DtdProcessing.Prohibit) { Throw(SR.Xml_DtdIsProhibitedEx, string.Empty); } else if (_dtdProcessing == DtdProcessing.Ignore) { return(Read()); } if (_checkCharacters) { ValidateQName(base.reader.Name); CheckCharacters(base.reader.Value); string str; str = base.reader.GetAttribute("SYSTEM"); if (str != null) { CheckCharacters(str); } str = base.reader.GetAttribute("PUBLIC"); if (str != null) { int i; if ((i = _xmlCharType.IsPublicId(str)) >= 0) { Throw(SR.Xml_InvalidCharacter, XmlException.BuildCharExceptionArgs(str, i)); } } } break; case XmlNodeType.Whitespace: if (_ignoreWhitespace) { return(Read()); } if (_checkCharacters) { CheckWhitespace(base.reader.Value); } break; case XmlNodeType.SignificantWhitespace: if (_checkCharacters) { CheckWhitespace(base.reader.Value); } break; case XmlNodeType.EndElement: if (_checkCharacters) { ValidateQName(base.reader.Prefix, base.reader.LocalName); } break; default: break; } _lastNodeType = nodeType; return(true); } }
public override bool Read() { XmlNodeType type; switch (this.state) { case State.Initial: this.state = State.Interactive; if (base.reader.ReadState != System.Xml.ReadState.Initial) { goto Label_0055; } break; case State.InReadBinary: this.FinishReadBinary(); this.state = State.Interactive; break; case State.Error: return(false); case State.Interactive: break; default: return(false); } if (!base.reader.Read()) { return(false); } Label_0055: type = base.reader.NodeType; if (this.checkCharacters) { switch (type) { case XmlNodeType.Element: if (this.checkCharacters) { this.ValidateQName(base.reader.Prefix, base.reader.LocalName); if (base.reader.MoveToFirstAttribute()) { do { this.ValidateQName(base.reader.Prefix, base.reader.LocalName); this.CheckCharacters(base.reader.Value); }while (base.reader.MoveToNextAttribute()); base.reader.MoveToElement(); } } break; case XmlNodeType.Text: case XmlNodeType.CDATA: if (this.checkCharacters) { this.CheckCharacters(base.reader.Value); } break; case XmlNodeType.EntityReference: if (this.checkCharacters) { this.ValidateQName(base.reader.Name); } break; case XmlNodeType.ProcessingInstruction: if (!this.ignorePis) { if (this.checkCharacters) { this.ValidateQName(base.reader.Name); this.CheckCharacters(base.reader.Value); } break; } return(this.Read()); case XmlNodeType.Comment: if (!this.ignoreComments) { if (this.checkCharacters) { this.CheckCharacters(base.reader.Value); } break; } return(this.Read()); case XmlNodeType.DocumentType: if (this.dtdProcessing != DtdProcessing.Prohibit) { if (this.dtdProcessing == DtdProcessing.Ignore) { return(this.Read()); } } else { this.Throw("Xml_DtdIsProhibitedEx", string.Empty); } if (this.checkCharacters) { int num; this.ValidateQName(base.reader.Name); this.CheckCharacters(base.reader.Value); string attribute = base.reader.GetAttribute("SYSTEM"); if (attribute != null) { this.CheckCharacters(attribute); } attribute = base.reader.GetAttribute("PUBLIC"); if ((attribute != null) && ((num = this.xmlCharType.IsPublicId(attribute)) >= 0)) { this.Throw("Xml_InvalidCharacter", XmlException.BuildCharExceptionArgs(attribute, num)); } } break; case XmlNodeType.Whitespace: if (!this.ignoreWhitespace) { if (this.checkCharacters) { this.CheckWhitespace(base.reader.Value); } break; } return(this.Read()); case XmlNodeType.SignificantWhitespace: if (this.checkCharacters) { this.CheckWhitespace(base.reader.Value); } break; case XmlNodeType.EndElement: if (this.checkCharacters) { this.ValidateQName(base.reader.Prefix, base.reader.LocalName); } break; } } else { switch (type) { case XmlNodeType.ProcessingInstruction: if (!this.ignorePis) { break; } return(this.Read()); case XmlNodeType.Comment: if (!this.ignoreComments) { break; } return(this.Read()); case XmlNodeType.DocumentType: if (this.dtdProcessing != DtdProcessing.Prohibit) { if (this.dtdProcessing == DtdProcessing.Ignore) { return(this.Read()); } break; } this.Throw("Xml_DtdIsProhibitedEx", string.Empty); break; case XmlNodeType.Whitespace: if (!this.ignoreWhitespace) { break; } return(this.Read()); } return(true); } this.lastNodeType = type; return(true); }
private void ValidateNCName(string ncname) { if (ncname.Length == 0) { throw new ArgumentException(SR.Xml_EmptyName); } int len = ValidateNames.ParseNCName(ncname, 0); if (len != ncname.Length) { throw new ArgumentException(string.Format(len == 0 ? SR.Xml_BadStartNameChar : SR.Xml_BadNameChar, XmlException.BuildCharExceptionArgs(ncname, len))); } }
public override async Task WriteDocTypeAsync(string name, string pubid, string sysid, string subset) { try { if (name == null || name.Length == 0) { throw new ArgumentException(SR.Xml_EmptyName); } XmlConvert.VerifyQName(name, ExceptionType.XmlException); if (_conformanceLevel == ConformanceLevel.Fragment) { throw new InvalidOperationException(SR.Xml_DtdNotAllowedInFragment); } await AdvanceStateAsync(Token.Dtd).ConfigureAwait(false); if (_dtdWritten) { _currentState = State.Error; throw new InvalidOperationException(SR.Xml_DtdAlreadyWritten); } if (_conformanceLevel == ConformanceLevel.Auto) { _conformanceLevel = ConformanceLevel.Document; _stateTable = s_stateTableDocument; } int i; // check characters if (_checkCharacters) { if (pubid != null) { if ((i = _xmlCharType.IsPublicId(pubid)) >= 0) { throw new ArgumentException(SR.Format(SR.Xml_InvalidCharacter, XmlException.BuildCharExceptionArgs(pubid, i)), "pubid"); } } if (sysid != null) { if ((i = _xmlCharType.IsOnlyCharData(sysid)) >= 0) { throw new ArgumentException(SR.Format(SR.Xml_InvalidCharacter, XmlException.BuildCharExceptionArgs(sysid, i)), "sysid"); } } if (subset != null) { if ((i = _xmlCharType.IsOnlyCharData(subset)) >= 0) { throw new ArgumentException(SR.Format(SR.Xml_InvalidCharacter, XmlException.BuildCharExceptionArgs(subset, i)), "subset"); } } } // write doctype await _writer.WriteDocTypeAsync(name, pubid, sysid, subset).ConfigureAwait(false); _dtdWritten = true; } catch { _currentState = State.Error; throw; } }
public override void WriteWhitespace(string ws) { if (ws == null) { ws = string.Empty; } // "checkNames" is intentional here; if false, the whitespaces are checked in XmlWellformedWriter if (checkNames) { int i; if ((i = xmlCharType.IsOnlyWhitespaceWithPos(ws)) != -1) { throw new ArgumentException(Res.GetString(Res.Xml_InvalidWhitespaceCharacter, XmlException.BuildCharExceptionArgs(ws, i))); } } if (replaceNewLines) { ws = ReplaceNewLines(ws); } writer.WriteWhitespace(ws); }
internal static Exception CreateInvalidCharException(string data, int invCharPos, ExceptionType exceptionType) { return(CreateException(SR.Xml_InvalidCharacter, XmlException.BuildCharExceptionArgs(data, invCharPos), exceptionType, 0, invCharPos + 1)); }
private void ValidateNCName(string ncname) { if (ncname.Length == 0) { throw new ArgumentException(Res.GetString("Xml_EmptyName")); } int invCharIndex = ValidateNames.ParseNCName(ncname, 0); if (invCharIndex != ncname.Length) { throw new ArgumentException(Res.GetString((invCharIndex == 0) ? "Xml_BadStartNameChar" : "Xml_BadNameChar", XmlException.BuildCharExceptionArgs(ncname, invCharIndex))); } }
internal static Exception CreateInvalidNameCharException(string name, int index, ExceptionType exceptionType) { return(CreateException(index == 0 ? SR.Xml_BadStartNameChar : SR.Xml_BadNameChar, XmlException.BuildCharExceptionArgs(name, index), exceptionType, 0, index + 1)); }
internal static Exception CreateInvalidCharException(char invChar, char nextChar, ExceptionType exceptionType) { return(CreateException(SR.Xml_InvalidCharacter, XmlException.BuildCharExceptionArgs(invChar, nextChar), exceptionType)); }