// SxS: This function calls ValidateElement on XmlSchemaValidator which is annotated with ResourceExposure attribute.
// Since the resource names passed to ValidateElement method are null and the function does not expose any resources
// it is fine to supress the warning.
private void ValidateSingleElement(XmlElement elementNode, bool skipToEnd, XmlSchemaInfo newSchemaInfo)
{
_nsManager.PushScope();
Debug.Assert(elementNode != null);
XmlAttributeCollection attributes = elementNode.Attributes;
XmlAttribute attr = null;
//Find Xsi attributes that need to be processed before validating the element
string xsiNil = null;
string xsiType = null;
for (int i = 0; i < attributes.Count; i++)
{
attr = attributes[i];
string objectNs = attr.NamespaceURI;
string objectName = attr.LocalName;
Debug.Assert(_nameTable.Get(attr.NamespaceURI) != null);
Debug.Assert(_nameTable.Get(attr.LocalName) != null);
if (Ref.Equal(objectNs, _nsXsi))
{
if (Ref.Equal(objectName, _xsiType))
{
xsiType = attr.Value;
}
else if (Ref.Equal(objectName, _xsiNil))
{
xsiNil = attr.Value;
}
}
else if (Ref.Equal(objectNs, _nsXmlNs))
{
_nsManager.AddNamespace(attr.Prefix.Length == 0 ? string.Empty : attr.LocalName, attr.Value);
}
}
_validator.ValidateElement(elementNode.LocalName, elementNode.NamespaceURI, newSchemaInfo, xsiType, xsiNil, null, null);
//Validate end of element
if (skipToEnd)
{
_validator.ValidateEndOfAttributes(newSchemaInfo);
_validator.SkipToEndElement(newSchemaInfo);
_nsManager.PopScope(); //Pop current namespace scope
}
}
private int GetAttributeIndexWithPrefix(string name)
{
name = _coreReaderNameTable.Get(name);
if (name == null)
{
return(-1);
}
ValidatingReaderNodeData attribute;
for (int i = 0; i < _attributeCount; i++)
{
attribute = _attributeEvents[i];
if (Ref.Equal(attribute.GetAtomizedNameWPrefix(_coreReaderNameTable), name))
{
return(i);
}
}
return(-1);
}
private int GetAttributeIndexWithoutPrefix(string name)
{
name = _coreReaderNameTable.Get(name);
if (name == null)
{
return(-1);
}
ValidatingReaderNodeData attribute;
for (int i = 0; i < _attributeCount; i++)
{
attribute = _attributeEvents[i];
if (Ref.Equal(attribute.LocalName, name) && attribute.Prefix.Length == 0)
{
return(i);
}
}
return(-1);
}
// Moves to the attribute with the specified LocalName and NamespaceURI
public override bool MoveToAttribute(string name, string ns)
{
ns = (ns == null) ? string.Empty : _coreReaderNameTable.Get(ns);
name = _coreReaderNameTable.Get(name);
ValidatingReaderNodeData attribute;
for (int i = 0; i < _attributeCount; i++)
{
attribute = _attributeEvents[i];
if (Ref.Equal(attribute.LocalName, name) &&
Ref.Equal(attribute.Namespace, ns))
{
_currentAttrIndex = i;
_cachedNode = _attributeEvents[i];
return(true);
}
}
return(false);
}
// if the current node a matching element node
private bool IsMatch(XmlNode curNode)
{
if (curNode.NodeType == XmlNodeType.Element)
{
if (_name != null)
{
if (Ref.Equal(_name, _asterisk) || Ref.Equal(curNode.Name, _name))
{
return(true);
}
}
else
{
if (
(Ref.Equal(_localName, _asterisk) || Ref.Equal(curNode.LocalName, _localName)) &&
(Ref.Equal(_namespaceURI, _asterisk) || curNode.NamespaceURI == _namespaceURI)
)
{
return(true);
}
}
}
return(false);
}
// SxS: This function calls ValidateElement on XmlSchemaValidator which is annotated with ResourceExposure attribute.
// Since the resource names passed to ValidateElement method are null and the function does not expose any resources
// it is fine to disable the SxS warning.
private void ValidateElement()
{
_nsManager.PushScope();
XmlElement elementNode = _currentNode as XmlElement;
Debug.Assert(elementNode != null);
XmlAttributeCollection attributes = elementNode.Attributes;
XmlAttribute attr = null;
//Find Xsi attributes that need to be processed before validating the element
string xsiNil = null;
string xsiType = null;
for (int i = 0; i < attributes.Count; i++)
{
attr = attributes[i];
string objectNs = attr.NamespaceURI;
string objectName = attr.LocalName;
Debug.Assert(_nameTable.Get(attr.NamespaceURI) != null);
Debug.Assert(_nameTable.Get(attr.LocalName) != null);
if (Ref.Equal(objectNs, _nsXsi))
{
if (Ref.Equal(objectName, _xsiType))
{
xsiType = attr.Value;
}
else if (Ref.Equal(objectName, _xsiNil))
{
xsiNil = attr.Value;
}
}
else if (Ref.Equal(objectNs, _nsXmlNs))
{
_nsManager.AddNamespace(attr.Prefix.Length == 0 ? string.Empty : attr.LocalName, attr.Value);
}
}
_validator.ValidateElement(elementNode.LocalName, elementNode.NamespaceURI, _schemaInfo, xsiType, xsiNil, null, null);
ValidateAttributes(elementNode);
_validator.ValidateEndOfAttributes(_schemaInfo);
//If element has children, drill down
for (XmlNode child = elementNode.FirstChild; child != null; child = child.NextSibling)
{
ValidateNode(child);
}
//Validate end of element
_currentNode = elementNode; //Reset current Node for validation call back
_validator.ValidateEndElement(_schemaInfo);
//Get XmlName, as memberType / validity might be set now
if (_psviAugmentation)
{
elementNode.XmlName = _document.AddXmlName(elementNode.Prefix, elementNode.LocalName, elementNode.NamespaceURI, _schemaInfo);
if (_schemaInfo.IsDefault)
{ //the element has a default value
XmlText textNode = _document.CreateTextNode(_schemaInfo.SchemaElement.ElementDecl.DefaultValueRaw);
elementNode.AppendChild(textNode);
}
}
_nsManager.PopScope(); //Pop current namespace scope
}
public virtual void AddNamespace(string prefix, string uri)
{
if (uri == null)
{
throw new ArgumentNullException("uri");
}
if (prefix == null)
{
throw new ArgumentNullException("prefix");
}
prefix = _nameTable.Add(prefix);
uri = _nameTable.Add(uri);
if ((Ref.Equal(_xml, prefix) && !uri.Equals(XmlReservedNs.NsXml)))
{
throw new ArgumentException(ResXml.Xml_XmlPrefix);
}
if (Ref.Equal(_xmlNs, prefix))
{
throw new ArgumentException(ResXml.Xml_XmlnsPrefix);
}
int declIndex = LookupNamespaceDecl(prefix);
int previousDeclIndex = -1;
if (declIndex != -1)
{
if (_nsdecls[declIndex].scopeId == _scopeId)
{
// redefine if in the same scope
_nsdecls[declIndex].uri = uri;
return;
}
else
{
// othewise link
previousDeclIndex = declIndex;
}
}
// set new namespace declaration
if (_lastDecl == _nsdecls.Length - 1)
{
NamespaceDeclaration[] newNsdecls = new NamespaceDeclaration[_nsdecls.Length * 2];
Array.Copy(_nsdecls, 0, newNsdecls, 0, _nsdecls.Length);
_nsdecls = newNsdecls;
}
_nsdecls[++_lastDecl].Set(prefix, uri, _scopeId, previousDeclIndex);
// add to hashTable
if (_useHashtable)
{
_hashTable[prefix] = _lastDecl;
}
// or create a new hashTable if the threashold has been reached
else if (_lastDecl >= MinDeclsCountForHashtable)
{
// add all to hash table
Debug.Assert(_hashTable == null);
_hashTable = new Dictionary <string, int>(_lastDecl);
for (int i = 0; i <= _lastDecl; i++)
{
_hashTable[_nsdecls[i].prefix] = i;
}
_useHashtable = true;
}
}
// SxS: This function calls ValidateElement on XmlSchemaValidator which is annotated with ResourceExposure attribute.
// Since the resource names (namespace location) are not provided directly by the user (they are read from the source
// document) and the function does not expose any resources it is fine to disable the SxS warning.
private async Task ProcessElementEventAsync()
{
if (_processInlineSchema && IsXSDRoot(_coreReader.LocalName, _coreReader.NamespaceURI) && _coreReader.Depth > 0)
{
_xmlSchemaInfo.Clear();
_attributeCount = _coreReaderAttributeCount = _coreReader.AttributeCount;
if (!_coreReader.IsEmptyElement)
{ //If its not empty schema, then parse else ignore
_inlineSchemaParser = new Parser(SchemaType.XSD, _coreReaderNameTable, _validator.SchemaSet.GetSchemaNames(_coreReaderNameTable), _validationEvent);
await _inlineSchemaParser.StartParsingAsync(_coreReader, null).ConfigureAwait(false);
_inlineSchemaParser.ParseReaderNode();
_validationState = ValidatingReaderState.ParseInlineSchema;
}
else
{
_validationState = ValidatingReaderState.ClearAttributes;
}
}
else
{ //Validate element
//Clear previous data
_atomicValue = null;
_originalAtomicValueString = null;
_xmlSchemaInfo.Clear();
if (_manageNamespaces)
{
_nsManager.PushScope();
}
//Find Xsi attributes that need to be processed before validating the element
string xsiSchemaLocation = null;
string xsiNoNamespaceSL = null;
string xsiNil = null;
string xsiType = null;
if (_coreReader.MoveToFirstAttribute())
{
do
{
string objectNs = _coreReader.NamespaceURI;
string objectName = _coreReader.LocalName;
if (Ref.Equal(objectNs, _nsXsi))
{
if (Ref.Equal(objectName, _xsiSchemaLocation))
{
xsiSchemaLocation = _coreReader.Value;
}
else if (Ref.Equal(objectName, _xsiNoNamespaceSchemaLocation))
{
xsiNoNamespaceSL = _coreReader.Value;
}
else if (Ref.Equal(objectName, _xsiType))
{
xsiType = _coreReader.Value;
}
else if (Ref.Equal(objectName, _xsiNil))
{
xsiNil = _coreReader.Value;
}
}
if (_manageNamespaces && Ref.Equal(_coreReader.NamespaceURI, _nsXmlNs))
{
_nsManager.AddNamespace(_coreReader.Prefix.Length == 0 ? string.Empty : _coreReader.LocalName, _coreReader.Value);
}
} while (_coreReader.MoveToNextAttribute());
_coreReader.MoveToElement();
}
_validator.ValidateElement(_coreReader.LocalName, _coreReader.NamespaceURI, _xmlSchemaInfo, xsiType, xsiNil, xsiSchemaLocation, xsiNoNamespaceSL);
ValidateAttributes();
_validator.ValidateEndOfAttributes(_xmlSchemaInfo);
if (_coreReader.IsEmptyElement)
{
await ProcessEndElementEventAsync().ConfigureAwait(false);
}
_validationState = ValidatingReaderState.ClearAttributes;
}
}