public static XmlNode CreateNode(XmlNodeType type, string name)
{
XmlDocument document = new XmlDocument();
XmlNode node = document.CreateNode(type, name, null);
return node;
}
public override void Close()
{
this.nav = XmlEmptyNavigator.Singleton;
this.nodeType = XmlNodeType.None;
this.state = State.Closed;
this.depth = 0;
}
public XmlValidatingReader( Stream xmlFragment, XmlNodeType fragType, XmlParserContext context ) {
if (xmlFragment == null) {
throw new ArgumentNullException("xmlFragment");
}
impl = new XmlValidatingReaderImpl(xmlFragment, fragType, context);
impl.OuterReader = this;
}
public void AdvanceNode(XmlNodeType xmlNodeType)
{
AdvanceNode();
if (m_xmlReader.NodeType != xmlNodeType)
throw new Exception("The expected node is " + xmlNodeType);
}
/// <summary>
/// Initializes a new instance of the OpenXmlMiscNode class using the
/// supplied XmlNodeType and outer XML values.
/// </summary>
/// <param name="nodeType">The XmlNodeType value.</param>
/// <param name="outerXml">The outer XML of the element.</param>
public OpenXmlMiscNode(XmlNodeType nodeType, string outerXml)
: this(nodeType)
{
if ( String.IsNullOrEmpty( outerXml ) )
{
throw new ArgumentNullException("outerXml");
}
// check the out XML match the nodeType
using (StringReader stringReader = new StringReader(outerXml))
{
XmlReaderSettings settings = new XmlReaderSettings();
settings.DtdProcessing = DtdProcessing.Prohibit; // set true explicitly for serucity fix
using (XmlReader xmlReader = XmlConvertingReaderFactory.Create(stringReader, settings))
{
xmlReader.Read();
if (xmlReader.NodeType != nodeType)
{
throw new ArgumentException(ExceptionMessages.InvalidOuterXmlForMiscNode);
}
xmlReader.Close();
}
}
this.RawOuterXml = outerXml;
}
public static object LoadXml(string fragment, XmlNodeType xmlNodeType, object target, string filename)
{
XamlParser parser = new XamlParser();
parser._filename = filename;
return parser.Read(fragment, xmlNodeType, target);
}
void AssertNode (int depth, string localName, XmlNodeType nodeType, string value, string type, XmlDictionaryReader reader, string label)
{
Assert.AreEqual (localName, reader.LocalName, label + ".LocalName");
Assert.AreEqual (nodeType, reader.NodeType, label + ".NodeType");
Assert.AreEqual (value, reader.Value, label + ".Value");
Assert.AreEqual (type, reader.GetAttribute ("type"), label + ".GetAttribute('type')");
}
private static void VerifyOwnerOfGivenType(XmlNodeType nodeType)
{
var xmlDocument = new XmlDocument();
var node = xmlDocument.CreateNode(nodeType, "test", string.Empty);
Assert.Equal(xmlDocument, node.OwnerDocument);
}
private void AssertNodeValues (
XmlReader xmlReader,
XmlNodeType nodeType,
int depth,
bool isEmptyElement,
string name,
string prefix,
string localName,
string namespaceURI,
string value,
int attributeCount)
{
Assert.AreEqual (nodeType, xmlReader.NodeType, "NodeType");
Assert.AreEqual (depth, xmlReader.Depth, "Depth");
Assert.AreEqual (isEmptyElement, xmlReader.IsEmptyElement, "IsEmptyElement");
Assert.AreEqual (name, xmlReader.Name, "name");
Assert.AreEqual (prefix, xmlReader.Prefix, "prefix");
Assert.AreEqual (localName, xmlReader.LocalName, "localName");
Assert.AreEqual (namespaceURI, xmlReader.NamespaceURI, "namespaceURI");
Assert.AreEqual ((value != String.Empty), xmlReader.HasValue, "hasValue");
Assert.AreEqual (value, xmlReader.Value, "Value");
Assert.AreEqual (attributeCount > 0, xmlReader.HasAttributes, "hasAttributes");
Assert.AreEqual (attributeCount, xmlReader.AttributeCount, "attributeCount");
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="value">innerText for this node</param>
/// <param name="nodeType">type of node</param>
internal XmlDiffViewCharData(
string value,
XmlNodeType nodeType)
: base(nodeType)
{
this.InnerText = value;
}
/// <summary>
/// Consumes nodes from the reader until the first ocurance of the XmlNodeType identified within types.
/// </summary>
/// <param name="reader">The reader from which to consume Xml nodes</param>
/// <param name="types">The XmlNodeType types of interest which will halt consumption</param>
public static void ConsumeUntilFirst(this XmlReader reader, XmlNodeType[] types)
{
while (Array.IndexOf(types, reader.NodeType) < 0)
{
reader.Read();
}
}
internal override bool IsValidChildType(XmlNodeType type)
{
switch (type)
{
case XmlNodeType.Element:
case XmlNodeType.Text:
case XmlNodeType.CDATA:
case XmlNodeType.EntityReference:
case XmlNodeType.ProcessingInstruction:
case XmlNodeType.Comment:
case XmlNodeType.Whitespace:
case XmlNodeType.SignificantWhitespace:
return true;
case XmlNodeType.XmlDeclaration:
{
XmlNode firstChild = this.FirstChild;
if ((firstChild != null) && (firstChild.NodeType == XmlNodeType.XmlDeclaration))
{
return false;
}
return true;
}
}
return false;
}
private void AssertNodeValues (
XmlReader xmlReader,
XmlNodeType nodeType,
int depth,
bool isEmptyElement,
string name,
string prefix,
string localName,
string namespaceURI,
string value,
int attributeCount)
{
AssertEquals ("NodeType", nodeType, xmlReader.NodeType);
AssertEquals ("Depth", depth, xmlReader.Depth);
AssertEquals ("IsEmptyElement", isEmptyElement, xmlReader.IsEmptyElement);
AssertEquals ("name", name, xmlReader.Name);
AssertEquals ("prefix", prefix, xmlReader.Prefix);
AssertEquals ("localName", localName, xmlReader.LocalName);
AssertEquals ("namespaceURI", namespaceURI, xmlReader.NamespaceURI);
AssertEquals ("hasValue", (value != String.Empty), xmlReader.HasValue);
AssertEquals ("Value", value, xmlReader.Value);
AssertEquals ("hasAttributes", attributeCount > 0, xmlReader.HasAttributes);
AssertEquals ("attributeCount", attributeCount, xmlReader.AttributeCount);
}
public ParserNode(string name, string value, XmlNodeType nodeType)
{
Name = name;
Value = value;
NodeType = nodeType;
Attributes = new Dictionary<string, string>();
}
private static void TwoTextNodeBase(XmlDocument xmlDocument, InsertType insertType, XmlNodeType nodeType)
{
XmlNode parent = xmlDocument.DocumentElement;
XmlNode refChild = (insertType == InsertType.Prepend) ? parent.FirstChild : parent.LastChild;
XmlNode newChild = TestHelper.CreateNode(xmlDocument, nodeType);
string original = parent.InnerXml;
string expected = (insertType == InsertType.Prepend) ? (newChild.OuterXml + parent.InnerXml)
: ((insertType == InsertType.Append) ? (parent.InnerXml + newChild.OuterXml)
: (refChild.PreviousSibling.OuterXml + newChild.OuterXml + refChild.OuterXml));
// insert new child
var insertDelegate = TestHelper.CreateInsertBeforeOrAfter(insertType);
insertDelegate(parent, newChild, refChild);
// verify
Assert.Equal(3, parent.ChildNodes.Count);
Assert.Equal(expected, parent.InnerXml);
TestHelper.Verify(parent, refChild, newChild);
TestHelper.VerifySiblings(refChild, newChild, insertType);
if (insertType == InsertType.Prepend || insertType == InsertType.Append)
TestHelper.Verify(refChild, newChild, insertType);
// delete new child
parent.RemoveChild(newChild);
Assert.Equal(2, parent.ChildNodes.Count);
TestHelper.VerifySiblings(parent.FirstChild, parent.LastChild, InsertType.Append);
Assert.Equal(original, parent.InnerXml);
}
public XmlValidatingReader(String xmlFragment, XmlNodeType fragType,
XmlParserContext context)
{
reader = new XmlTextReader(xmlFragment, fragType, context);
entityHandling = EntityHandling.ExpandEntities;
validationType = ValidationType.Auto;
reader.Normalization = true;
}
public void AdvanceNamedNode(XmlNodeType xmlNodeType, string nodeName)
{
AdvanceNode(xmlNodeType);
if (m_xmlReader.Name != nodeName)
throw new Exception("Node '" + nodeName + "' of type '"
+ xmlNodeType + "' expected");
}
void AssertNode (XmlNodeType nodeType, string localName, string ns, string value, int depth, XmlReader reader, string label)
{
Assert.AreEqual (nodeType, reader.NodeType, label + ".Node");
Assert.AreEqual (localName, reader.LocalName, label + ".LocalName");
Assert.AreEqual (ns, reader.NamespaceURI, label + ".NS");
Assert.AreEqual (value, reader.Value, label + ".Value");
Assert.AreEqual (depth, reader.Depth, label + ".Depth");
}
/// <summary>
/// Initializes a new instance of the <see cref="NodeHandlerAttribute"/> class.
/// </summary>
/// <param name="nodeType">The type of the node being handled.</param>
/// <param name="nodeName">The name of the node being handled.</param>
/// <param name="ns">The namespace of the node being handled.</param>
public NodeHandlerAttribute(XmlNodeType nodeType, string nodeName, string ns = null)
{
Contract.Requires<ArgumentNullException>(!string.IsNullOrWhiteSpace(nodeName));
this.NodeType = nodeType;
this.NodeName = nodeName.Substring(nodeName.IndexOf(":", StringComparison.Ordinal) + 1);
this.Namespace = ns;
}
//********************************************************************************
/// <summary>
///
/// </summary>
/// <returns></returns>
/// <created>UPh,20.03.2013</created>
/// <changed>UPh,20.03.2013</changed>
//********************************************************************************
public CXmlNode()
{
m_nDepth = 0;
m_nNodeType = XmlNodeType.None;
m_bEmptyElement = false;
m_pReader = null;
m_pWriter = null;
}
internal XmlBasicTokenInfo(XmlScanner scanner, XmlNamespaceManager nsMgr, XmlNodeType type, int depth) {
_Scanner = scanner;
_NsMgr = nsMgr;
_NodeType = type;
_Depth = depth;
_LineNum = 0;
_LinePos = 0;
}
internal void Set( XmlNodeType nodeType, string localName, string prefix, string name, string namespaceUri, string value ) {
this.type = nodeType;
this.localName = localName;
this.prefix = prefix;
this.name = name;
this.namespaceUri = namespaceUri;
this.value = value;
}
internal override bool IsValidChildType(XmlNodeType type)
{
if ((((type != XmlNodeType.Text) && (type != XmlNodeType.Element)) && ((type != XmlNodeType.ProcessingInstruction) && (type != XmlNodeType.Comment))) && (((type != XmlNodeType.CDATA) && (type != XmlNodeType.Whitespace)) && (type != XmlNodeType.SignificantWhitespace)))
{
return (type == XmlNodeType.EntityReference);
}
return true;
}
public static bool FindNode(XmlReader reader, XmlNodeType type)
{
do {
if(reader.NodeType==type) return true;
} while(reader.Read());
return false;
}
private XmlToken(XmlNodeType kind)
{
_Name = null;
_Kind = kind;
_Value = null;
_LineNumber = null;
_LinePosition = null;
}
internal XmlAttributeTokenInfo(XmlScanner scanner, XmlNamespaceManager nsMgr, XmlNodeType type, bool nor) : this() {
_NsMgr = nsMgr;
_Scanner = scanner;
_NodeType = type;
_NormalizeText = nor;
_HasNormalize = !_NormalizeText;
}
private XmlToken(XmlNodeType kind)
{
_Name = null;
_Kind = kind;
_IsEmptyElement = kind == XmlNodeType.Element;
_Value = null;
_LineNumber = null;
_LinePosition = null;
}
public static bool DefaultNodeTypeMatcher(XmlNodeType controlType,
XmlNodeType testType)
{
return controlType == testType
|| (controlType == XmlNodeType.CDATA
&& testType == XmlNodeType.Text)
|| (controlType == XmlNodeType.Text
&& testType == XmlNodeType.CDATA);
}
internal void SetTokenInfo(XmlNodeType nodeType, String name, int depth) {
_NodeType = nodeType;
//
// this name should already be atomalized
_Name = name;
Debug.Assert(Ref.Equal(_Name, _Scanner.GetTextAtom(name)), "Name should be atomalized");
_Depth = depth;
}
public XmlValidatingReader(string xmlFragment, XmlNodeType fragType, XmlParserContext context)
{
if (xmlFragment == null)
{
throw new ArgumentNullException(nameof(xmlFragment));
}
_impl = new XmlValidatingReaderImpl(xmlFragment, fragType, context);
_impl.OuterReader = this;
}
internal XmlTextReader(string baseURI, TextReader xmlFragment, XmlNodeType fragType, XmlParserContext context)
{
source = new XmlTextReaderImpl(baseURI, xmlFragment, fragType, context);
}
internal XmlTextReader(string baseURI, TextReader xmlFragment, XmlNodeType fragType)
{
source = new XmlTextReaderImpl(baseURI, xmlFragment, fragType);
}
// When reading an array (0x03), it requires extraneously
// complex procedure for XmlReader. First, it reads element,
// type of operation and length of the items. And this XmlReader
// has to return Element state. On the next Read(), it proceeds
// to the value node of the first item of the array, so it
// reads the value stream. On the next Read(), it proceeds to
// EndElement, so it should not read anything from stream while
// it has to move to the node state to EndElement.
public override bool Read()
{
switch (state)
{
case ReadState.Closed:
case ReadState.EndOfFile:
case ReadState.Error:
return(false);
}
// clear.
state = ReadState.Interactive;
MoveToElement();
attr_count = 0;
attr_value_count = 0;
ns_slot = 0;
if (node.NodeType == XmlNodeType.Element)
{
// push element scope
if (node_stack.Count <= ++depth)
{
if (depth == quota.MaxDepth)
{
throw new XmlException(String.Format("Binary XML stream quota exceeded. Depth must be less than {0}", quota.MaxDepth));
}
node = new NodeInfo();
node_stack.Add(node);
}
else
{
node = node_stack [depth]; // reuse
node.Reset();
}
}
current = node;
if (is_next_end_element)
{
is_next_end_element = false;
node.Reset();
ProcessEndElement();
return(true);
}
// process array node after preparing node stack.
switch (array_state)
{
case XmlNodeType.Element:
ReadArrayItem();
return(true);
case XmlNodeType.Text:
ShiftToArrayItemEndElement();
return(true);
case XmlNodeType.EndElement:
if (--array_item_remaining == 0)
{
array_state = XmlNodeType.None;
break;
}
else
{
ShiftToArrayItemElement();
return(true);
}
}
// array consumer does not expect Reset whlie it's on reading. So call it later than array check.
node.Reset();
int ident = next >= 0 ? next : source.ReadByte();
next = -1;
// check end of source.
if (ident < 0)
{
state = ReadState.EndOfFile;
current.Reset();
return(false);
}
is_next_end_element = ident > 0x80 && (ident & 1) == 1;
ident -= is_next_end_element ? 1 : 0;
switch (ident)
{
case BF.EndElement:
ProcessEndElement();
break;
case BF.Comment:
node.Value = ReadUTF8();
node.ValueType = BF.Comment;
node.NodeType = XmlNodeType.Comment;
break;
case BF.ElemString:
case BF.ElemStringPrefix:
case BF.ElemIndex:
case BF.ElemIndexPrefix:
ReadElementBinary((byte)ident);
break;
case BF.Array:
ident = ReadByteOrError();
ReadElementBinary((byte)ident);
ident = ReadByteOrError();
if (ident != 0x01)
{
throw new XmlException(String.Format("EndElement is expected after element in an array. The actual byte was {0:X} in hexadecimal", ident));
}
ident = ReadByteOrError() - 1; // -1 becauseit contains EndElement
VerifyValidArrayItemType(ident);
if (ident < 0)
{
throw new XmlException("The stream has ended where the array item type is expected");
}
array_item_type = (byte)ident;
array_item_remaining = ReadVariantSize();
if (array_item_remaining > quota.MaxArrayLength)
{
throw new Exception(String.Format("Binary xml stream exceeded max array length quota. Items are {0} and should be less than quota.MaxArrayLength", quota.MaxArrayLength));
}
array_state = XmlNodeType.Element;
break;
default:
if (BF.PrefixNElemIndexStart <= ident && ident <= BF.PrefixNElemIndexEnd ||
BF.PrefixNElemStringStart <= ident && ident <= BF.PrefixNElemStringEnd)
{
goto case BF.ElemString;
}
ReadTextOrValue((byte)ident, node, false);
break;
}
return(true);
}
internal static Exception CreateReadElementContentAsException(string methodName, XmlNodeType nodeType)
{
return((Exception) new InvalidOperationException(Res.GetString(51, (object[])new string[2]
{
methodName,
nodeType.ToString()
})));
}
void ShiftToArrayItemElement()
{
node.NodeType = XmlNodeType.Element;
context.NamespaceManager.PushScope();
array_state = XmlNodeType.Element;
}
public XmlValidatingReader([StringSyntax(StringSyntaxAttribute.Xml)] string xmlFragment, XmlNodeType fragType, XmlParserContext context)
{
ArgumentNullException.ThrowIfNull(xmlFragment);
_impl = new XmlValidatingReaderImpl(xmlFragment, fragType, context);
_impl.OuterReader = this;
}
// Creates an XmlNode with the specified XmlNodeType, Name, and
// NamespaceURI.
public virtual XmlNode CreateNode(XmlNodeType type, string name, string namespaceURI)
{
return(CreateNode(type, null, name, namespaceURI));
}
private async Task <Tuple <string, object> > InternalReadContentAsObjectTupleAsync(bool unwrapTypedValue)
{
Tuple <string, object> tuple;
string originalStringValue;
XmlNodeType nodeType = this.NodeType;
if (nodeType == XmlNodeType.Attribute)
{
originalStringValue = this.Value;
if (attributePSVI != null && attributePSVI.typedAttributeValue != null)
{
if (validationState == ValidatingReaderState.OnDefaultAttribute)
{
XmlSchemaAttribute schemaAttr = attributePSVI.attributeSchemaInfo.SchemaAttribute;
originalStringValue = (schemaAttr.DefaultValue != null) ? schemaAttr.DefaultValue : schemaAttr.FixedValue;
}
tuple = new Tuple <string, object>(originalStringValue, ReturnBoxedValue(attributePSVI.typedAttributeValue, AttributeSchemaInfo.XmlType, unwrapTypedValue));
return(tuple);
}
else //return string value
{
tuple = new Tuple <string, object>(originalStringValue, this.Value);
return(tuple);
}
}
else if (nodeType == XmlNodeType.EndElement)
{
if (atomicValue != null)
{
originalStringValue = originalAtomicValueString;
tuple = new Tuple <string, object>(originalStringValue, atomicValue);
return(tuple);
}
else
{
originalStringValue = string.Empty;
tuple = new Tuple <string, object>(originalStringValue, string.Empty);
return(tuple);
}
}
else //Positioned on text, CDATA, PI, Comment etc
{
if (validator.CurrentContentType == XmlSchemaContentType.TextOnly) //if current element is of simple type
{
object value = ReturnBoxedValue(await ReadTillEndElementAsync().ConfigureAwait(false), xmlSchemaInfo.XmlType, unwrapTypedValue);
originalStringValue = originalAtomicValueString;
tuple = new Tuple <string, object>(originalStringValue, value);
return(tuple);
}
else
{
XsdCachingReader cachingReader = this.coreReader as XsdCachingReader;
if (cachingReader != null)
{
originalStringValue = cachingReader.ReadOriginalContentAsString();
}
else
{
originalStringValue = await InternalReadContentAsStringAsync().ConfigureAwait(false);
}
tuple = new Tuple <string, object>(originalStringValue, originalStringValue);
return(tuple);
}
}
}
internal override bool IsValidChildType(XmlNodeType type)
{
return((type == XmlNodeType.Text) || (type == XmlNodeType.EntityReference));
}
// Determine if a particular node type can be inserted before another,
// which may be null if the list is currently empty.
internal override bool CanInsertBefore(XmlNodeType type, XmlNode refNode)
{
XmlNode temp;
// Filter out types that are definitely not allowed.
if (!CanInsert(type))
{
return(false);
}
// If nothing in the list yet, then we can insert anything.
if (refNode == null)
{
return(true);
}
// Handle special node categories.
switch (type)
{
case XmlNodeType.DocumentType:
{
// Must not have an element before this position.
temp = NodeList.GetPreviousSibling(refNode);
while (temp != null)
{
if (temp.NodeType == XmlNodeType.Element)
{
return(false);
}
temp = NodeList.GetPreviousSibling(temp);
}
// Must not have an XmlDeclaration after this position.
while (refNode != null)
{
if (refNode.NodeType == XmlNodeType.XmlDeclaration)
{
return(false);
}
refNode = NodeList.GetNextSibling(refNode);
}
}
break;
case XmlNodeType.Element:
{
// Must not have a document type or XmlDeclaration
// after this position.
while (refNode != null)
{
if (refNode.NodeType == XmlNodeType.DocumentType ||
refNode.NodeType == XmlNodeType.XmlDeclaration)
{
return(false);
}
refNode = NodeList.GetNextSibling(refNode);
}
}
break;
case XmlNodeType.XmlDeclaration:
{
// Xml declarations must come before everything else.
return(refNode == NodeList.GetFirstChild(this));
}
// Not reached.
}
// If we get here, then the node is allowed.
return(true);
}
public virtual XmlNode CreateNode(XmlNodeType type,
String prefix, String name,
String namespaceURI)
{
switch (type)
{
case XmlNodeType.Element:
{
if (prefix == null)
{
return(CreateElement(name, namespaceURI));
}
else
{
return(CreateElement(prefix, name, namespaceURI));
}
}
// Not reached
case XmlNodeType.Attribute:
{
if (prefix == null)
{
return(CreateAttribute(name, namespaceURI));
}
else
{
return(CreateAttribute(prefix, name, namespaceURI));
}
}
// Not reached
case XmlNodeType.Text:
{
return(CreateTextNode(String.Empty));
}
// Not reached
case XmlNodeType.CDATA:
{
return(CreateCDataSection(String.Empty));
}
// Not reached
case XmlNodeType.EntityReference:
{
return(CreateEntityReference(name));
}
// Not reached
case XmlNodeType.ProcessingInstruction:
{
return(CreateProcessingInstruction(name, String.Empty));
}
// Not reached
case XmlNodeType.Comment:
{
return(CreateComment(String.Empty));
}
// Not reached
case XmlNodeType.Document:
{
return(new XmlDocument());
}
// Not reached
case XmlNodeType.DocumentType:
{
return(CreateDocumentType(name, String.Empty,
String.Empty, String.Empty));
}
// Not reached
case XmlNodeType.DocumentFragment:
{
return(CreateDocumentFragment());
}
// Not reached
case XmlNodeType.Whitespace:
{
return(CreateWhitespace(String.Empty));
}
// Not reached
case XmlNodeType.SignificantWhitespace:
{
return(CreateSignificantWhitespace(String.Empty));
}
// Not reached
}
throw new ArgumentOutOfRangeException
("type", S._("Xml_InvalidNodeType"));
}
public virtual void WriteNode(XmlDictionaryReader reader, bool defattr)
{
if (reader == null)
{
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException(nameof(reader)));
}
int d = (reader.NodeType == XmlNodeType.None ? -1 : reader.Depth);
do
{
XmlNodeType nodeType = reader.NodeType;
Type type;
if (nodeType == XmlNodeType.Text || nodeType == XmlNodeType.Whitespace || nodeType == XmlNodeType.SignificantWhitespace)
{
// This will advance if necessary, so we don't need to call Read() explicitly
WriteTextNode(reader, false);
}
else if (reader.Depth > d && reader.IsStartArray(out type))
{
WriteArrayNode(reader, type);
}
else
{
// These will not advance, so we must call Read() explicitly
switch (nodeType)
{
case XmlNodeType.Element:
WriteElementNode(reader, defattr);
break;
case XmlNodeType.CDATA:
WriteCData(reader.Value);
break;
case XmlNodeType.EntityReference:
WriteEntityRef(reader.Name);
break;
case XmlNodeType.XmlDeclaration:
case XmlNodeType.ProcessingInstruction:
WriteProcessingInstruction(reader.Name, reader.Value);
break;
case XmlNodeType.DocumentType:
WriteDocType(reader.Name, reader.GetAttribute("PUBLIC"), reader.GetAttribute("SYSTEM"), reader.Value);
break;
case XmlNodeType.Comment:
WriteComment(reader.Value);
break;
case XmlNodeType.EndElement:
WriteFullEndElement();
break;
}
if (!reader.Read())
{
break;
}
}
}while (d < reader.Depth || (d == reader.Depth && reader.NodeType == XmlNodeType.EndElement));
}
internal XmlTextReader(bool dummy, XmlResolver resolver, string url, XmlNodeType fragType, XmlParserContext context)
{
source = new XmlTextReaderImpl(dummy, resolver, url, fragType, context);
}
internal void SetNamedNode(XmlNodeType type, string localName)
{
SetNamedNode(type, localName, string.Empty, localName);
}
// Creates a XmlNode with the specified XmlNodeType, Prefix, Name, and NamespaceURI.
public virtual XmlNode CreateNode(XmlNodeType type, string prefix, string name, string namespaceURI)
{
switch (type)
{
case XmlNodeType.Element:
if (prefix != null)
{
return(CreateElement(prefix, name, namespaceURI));
}
else
{
return(CreateElement(name, namespaceURI));
}
case XmlNodeType.Attribute:
if (prefix != null)
{
return(CreateAttribute(prefix, name, namespaceURI));
}
else
{
return(CreateAttribute(name, namespaceURI));
}
case XmlNodeType.Text:
return(CreateTextNode(string.Empty));
case XmlNodeType.CDATA:
return(CreateCDataSection(string.Empty));
case XmlNodeType.EntityReference:
return(CreateEntityReference(name));
case XmlNodeType.ProcessingInstruction:
return(CreateProcessingInstruction(name, string.Empty));
case XmlNodeType.XmlDeclaration:
return(CreateXmlDeclaration("1.0", null, null));
case XmlNodeType.Comment:
return(CreateComment(string.Empty));
case XmlNodeType.DocumentFragment:
return(CreateDocumentFragment());
case XmlNodeType.DocumentType:
return(CreateDocumentType(name, string.Empty, string.Empty, string.Empty));
case XmlNodeType.Document:
return(new XmlDocument());
case XmlNodeType.SignificantWhitespace:
return(CreateSignificantWhitespace(string.Empty));
case XmlNodeType.Whitespace:
return(CreateWhitespace(string.Empty));
default:
throw new ArgumentException(SR.Format(SR.Arg_CannotCreateNode, type));
}
}
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 XmlValidatingReader(string xmlFragment, XmlNodeType fragType, XmlParserContext context)
: this(new XmlTextReader(xmlFragment, fragType, context))
{
}
public ValidatingReaderNodeData(XmlNodeType nodeType)
{
Clear(nodeType);
}
private async Task <(string, object)> InternalReadContentAsObjectTupleAsync(bool unwrapTypedValue)
{
string originalStringValue;
XmlNodeType nodeType = this.NodeType;
if (nodeType == XmlNodeType.Attribute)
{
originalStringValue = this.Value;
if (_attributePSVI != null && _attributePSVI.typedAttributeValue != null)
{
if (_validationState == ValidatingReaderState.OnDefaultAttribute)
{
XmlSchemaAttribute schemaAttr = _attributePSVI.attributeSchemaInfo.SchemaAttribute !;
originalStringValue = (schemaAttr.DefaultValue != null) ? schemaAttr.DefaultValue : schemaAttr.FixedValue !;
}
return(originalStringValue, ReturnBoxedValue(_attributePSVI.typedAttributeValue, AttributeSchemaInfo.XmlType !, unwrapTypedValue));
}
else
{
// return string value
return(originalStringValue, this.Value);
}
}
else if (nodeType == XmlNodeType.EndElement)
{
if (_atomicValue != null)
{
Debug.Assert(_originalAtomicValueString != null);
originalStringValue = _originalAtomicValueString;
return(originalStringValue, _atomicValue);
}
else
{
originalStringValue = string.Empty;
return(originalStringValue, string.Empty);
}
}
else
{
// Positioned on text, CDATA, PI, Comment etc
if (_validator.CurrentContentType == XmlSchemaContentType.TextOnly)
{
// if current element is of simple type
object?value = ReturnBoxedValue(await ReadTillEndElementAsync().ConfigureAwait(false), _xmlSchemaInfo.XmlType !, unwrapTypedValue);
Debug.Assert(value != null);
Debug.Assert(_originalAtomicValueString != null);
originalStringValue = _originalAtomicValueString;
return(originalStringValue, value);
}
else
{
XsdCachingReader?cachingReader = _coreReader as XsdCachingReader;
if (cachingReader != null)
{
originalStringValue = cachingReader.ReadOriginalContentAsString();
}
else
{
originalStringValue = await InternalReadContentAsStringAsync().ConfigureAwait(false);
}
return(originalStringValue, originalStringValue);
}
}
}
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);
}
public XmlTextReader(string xmlFragment, XmlNodeType fragType, XmlParserContext context)
{
source = new XmlTextReaderImpl(xmlFragment, fragType, context);
}
public XmlTextReader(Stream xmlFragment, XmlNodeType fragType, XmlParserContext context)
{
impl = new XmlTextReaderImpl(xmlFragment, fragType, context);
impl.OuterReader = this;
}
public static XPathNavigator CreateNavigator(this XmlDocument document, XmlNode node)
{
XmlNodeType nodeType = node.NodeType;
XmlNode parent;
XmlNodeType parentType;
switch (nodeType)
{
case XmlNodeType.EntityReference:
case XmlNodeType.Entity:
case XmlNodeType.DocumentType:
case XmlNodeType.Notation:
case XmlNodeType.XmlDeclaration:
return(null);
case XmlNodeType.Text:
case XmlNodeType.CDATA:
case XmlNodeType.SignificantWhitespace:
parent = node.ParentNode;
while (parent != null)
{
parentType = parent.NodeType;
if (parentType == XmlNodeType.Attribute)
{
return(null);
}
else if (parentType == XmlNodeType.EntityReference)
{
parent = parent.ParentNode;
}
else
{
break;
}
}
node = NormalizeText(node);
break;
case XmlNodeType.Whitespace:
parent = node.ParentNode;
while (parent != null)
{
parentType = parent.NodeType;
if (parentType == XmlNodeType.Document ||
parentType == XmlNodeType.Attribute)
{
return(null);
}
else if (parentType == XmlNodeType.EntityReference)
{
parent = parent.ParentNode;
}
else
{
break;
}
}
node = NormalizeText(node);
break;
default:
break;
}
return(new DocumentXPathNavigator(document, node));
}
void ShiftToArrayItemEndElement()
{
ProcessEndElement();
array_state = XmlNodeType.EndElement;
}
internal XmlNamespaceManager ParsePartialContent(XmlNode parentNode, string innerxmltext, XmlNodeType nt)
{
//the function shouldn't be used to set innerxml for XmlDocument node
Debug.Assert(parentNode.NodeType != XmlNodeType.Document);
_doc = parentNode.OwnerDocument;
Debug.Assert(_doc != null);
XmlParserContext pc = GetContext(parentNode);
_reader = CreateInnerXmlReader(innerxmltext, nt, pc, _doc);
try
{
_preserveWhitespace = true;
bool bOrigLoading = _doc.IsLoading;
_doc.IsLoading = true;
if (nt == XmlNodeType.Entity)
{
XmlNode node = null;
while (_reader.Read() && (node = LoadNodeDirect()) != null)
{
parentNode.AppendChildForLoad(node, _doc);
}
}
else
{
XmlNode node = null;
while (_reader.Read() && (node = LoadNode(true)) != null)
{
parentNode.AppendChildForLoad(node, _doc);
}
}
_doc.IsLoading = bOrigLoading;
}
finally
{
_reader.Dispose();
}
return(pc.NamespaceManager);
}
internal virtual bool IsValidChildType(XmlNodeType type)
{
return(false);
}
#pragma warning restore 618
static internal Exception UnexpectedNodeType(XmlNodeType nodetype)
{
return(new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, SR.Xml_UnexpectedNodeType, nodetype.ToString())));
}
public XmlTextReader(string xmlFragment, XmlNodeType fragType, XmlParserContext context)
{
_impl = new XmlTextReaderImpl(xmlFragment, fragType, context);
_impl.OuterReader = this;
}
internal XmlAttributeTokenInfo(XmlScanner scanner, XmlNamespaceManager nsMgr, XmlNodeType type, bool nor) : this()
{
_NsMgr = nsMgr;
_Scanner = scanner;
_NodeType = type;
_NormalizeText = nor;
_HasNormalize = !_NormalizeText;
}
void ReadArrayItem()
{
ReadTextOrValue(array_item_type, node, false);
array_state = XmlNodeType.Text;
}
