/// <summary>
/// Create a writer that can be used to create nodes in this document. The root node will be assigned "baseUri", and flags
/// can be passed to indicate that names should be atomized by the builder and/or a fragment should be created.
/// </summary>
internal void LoadFromReader(XmlReader reader, XmlSpace space)
{
XPathDocumentBuilder builder;
IXmlLineInfo lineInfo;
string xmlnsUri;
bool topLevelReader;
int initialDepth;
if (reader == null)
{
throw new ArgumentNullException("reader");
}
// Determine line number provider
lineInfo = reader as IXmlLineInfo;
if (lineInfo == null || !lineInfo.HasLineInfo())
{
lineInfo = null;
}
_hasLineInfo = (lineInfo != null);
_nameTable = reader.NameTable;
builder = new XPathDocumentBuilder(this, lineInfo, reader.BaseURI, LoadFlags.None);
try
{
// Determine whether reader is in initial state
topLevelReader = (reader.ReadState == ReadState.Initial);
initialDepth = reader.Depth;
// Get atomized xmlns uri
Debug.Assert((object)_nameTable.Get(string.Empty) == (object)string.Empty, "NameTable must contain atomized string.Empty");
xmlnsUri = _nameTable.Get(XmlConst.ReservedNsXmlNs);
// Read past Initial state; if there are no more events then load is complete
if (topLevelReader && !reader.Read())
{
return;
}
// Read all events
do
{
// If reader began in intermediate state, return when all siblings have been read
if (!topLevelReader && reader.Depth < initialDepth)
{
return;
}
switch (reader.NodeType)
{
case XmlNodeType.Element:
{
bool isEmptyElement = reader.IsEmptyElement;
builder.WriteStartElement(reader.Prefix, reader.LocalName, reader.NamespaceURI, reader.BaseURI);
// Add attribute and namespace nodes to element
while (reader.MoveToNextAttribute())
{
string namespaceUri = reader.NamespaceURI;
if ((object)namespaceUri == (object)xmlnsUri)
{
if (reader.Prefix.Length == 0)
{
// Default namespace declaration "xmlns"
Debug.Assert(reader.LocalName == "xmlns");
builder.WriteNamespaceDeclaration(string.Empty, reader.Value);
}
else
{
Debug.Assert(reader.Prefix == "xmlns");
builder.WriteNamespaceDeclaration(reader.LocalName, reader.Value);
}
}
else
{
builder.WriteStartAttribute(reader.Prefix, reader.LocalName, namespaceUri);
builder.WriteString(reader.Value, TextBlockType.Text);
builder.WriteEndAttribute();
}
}
if (isEmptyElement)
{
builder.WriteEndElement(true);
}
break;
}
case XmlNodeType.EndElement:
builder.WriteEndElement(false);
break;
case XmlNodeType.Text:
case XmlNodeType.CDATA:
builder.WriteString(reader.Value, TextBlockType.Text);
break;
case XmlNodeType.SignificantWhitespace:
if (reader.XmlSpace == XmlSpace.Preserve)
{
builder.WriteString(reader.Value, TextBlockType.SignificantWhitespace);
}
else
{
// Significant whitespace without xml:space="preserve" is not significant in XPath/XQuery data model
goto case XmlNodeType.Whitespace;
}
break;
case XmlNodeType.Whitespace:
// We intentionally ignore the reader.XmlSpace property here and blindly trust
// the reported node type. If the reported information is not in sync
// (in this case if the reader.XmlSpace == Preserve) then we make the choice
// to trust the reported node type. Since we have no control over the input reader
// we can't even assert here.
// Always filter top-level whitespace
if (space == XmlSpace.Preserve && (!topLevelReader || reader.Depth != 0))
{
builder.WriteString(reader.Value, TextBlockType.Whitespace);
}
break;
case XmlNodeType.Comment:
builder.WriteComment(reader.Value);
break;
case XmlNodeType.ProcessingInstruction:
builder.WriteProcessingInstruction(reader.LocalName, reader.Value, reader.BaseURI);
break;
case XmlNodeType.EntityReference:
reader.ResolveEntity();
break;
case XmlNodeType.DocumentType:
case XmlNodeType.EndEntity:
case XmlNodeType.None:
case XmlNodeType.XmlDeclaration:
break;
}
}while (reader.Read());
}
finally
{
builder.CloseWithoutDisposing();
}
}
internal XDocument Build(XmlReader xmlReader)
{
XDocument doc = null;
_parent = null;
_root = null;
_prevNode = null;
_lastReadElementEmpty = false;
_lastTextRange = null;
// Enable getting line and column info
var lineInfo = xmlReader as IXmlLineInfo;
while (xmlReader.Read())
{
switch (xmlReader.NodeType)
{
case XmlNodeType.Element:
ProcessElement(xmlReader, lineInfo);
break;
case XmlNodeType.EndElement:
ProcessEndElement(lineInfo);
break;
case XmlNodeType.Text:
case XmlNodeType.SignificantWhitespace:
case XmlNodeType.Whitespace:
UpdateOpenTagEndInfo(
lineInfo.LineNumber,
lineInfo.LinePosition - TextOffset);
_prevNode = new XText(xmlReader.Value);
UpdateTextRange(_prevNode, lineInfo);
if (_parent != null)
{
_parent.Add(_prevNode);
}
break;
case XmlNodeType.CDATA:
UpdateOpenTagEndInfo(
lineInfo.LineNumber,
lineInfo.LinePosition - CDataOffset);
_prevNode = new XCData(xmlReader.Value);
UpdateTextRange(_prevNode, lineInfo);
if (_parent != null)
{
_parent.Add(_prevNode);
}
break;
case XmlNodeType.Comment:
UpdateOpenTagEndInfo(
lineInfo.LineNumber,
lineInfo.LinePosition - CommentOffset);
_prevNode = new XComment(xmlReader.Value);
UpdateTextRange(_prevNode, lineInfo);
if (_parent != null)
{
_parent.Add(_prevNode);
}
break;
case XmlNodeType.ProcessingInstruction:
UpdateOpenTagEndInfo(
lineInfo.LineNumber,
lineInfo.LinePosition - ProcessingInstructionOffset);
_prevNode = new XProcessingInstruction(
xmlReader.Name, xmlReader.Value);
UpdateTextRange(_prevNode, lineInfo);
if (_parent != null)
{
_parent.Add(_prevNode);
}
break;
case XmlNodeType.EntityReference:
xmlReader.ResolveEntity();
break;
case XmlNodeType.DocumentType:
break;
case XmlNodeType.XmlDeclaration:
break;
case XmlNodeType.EndEntity:
break;
default:
throw new InvalidOperationException(Resources.TreeBuilder_UnknownNodeType);
}
}
doc = new XDocument(_root);
doc.Root.EnsureAnnotation();
return(doc);
}
// This class itself does not have this feature.
public override void ResolveEntity()
{
reader.ResolveEntity();
}
/// <summary></summary>
public override void ResolveEntity()
{
Console.WriteLine("ResolveEntity");
_internal.ResolveEntity();
}
public override void ResolveEntity()
{
_tr.ResolveEntity();
}
public override void ResolveEntity()
{
_proxy.ResolveEntity();
}
public override void ResolveEntity()
{
m_inner.ResolveEntity();
}
internal void ReadContentFrom(XmlReader r, LoadOptions o)
{
if ((o & (LoadOptions.SetBaseUri | LoadOptions.SetLineInfo)) == 0)
{
ReadContentFrom(r);
return;
}
if (r.ReadState != ReadState.Interactive) throw new InvalidOperationException(SR.InvalidOperation_ExpectedInteractive);
XContainer c = this;
XNode n = null;
NamespaceCache eCache = new NamespaceCache();
NamespaceCache aCache = new NamespaceCache();
string baseUri = (o & LoadOptions.SetBaseUri) != 0 ? r.BaseURI : null;
IXmlLineInfo li = (o & LoadOptions.SetLineInfo) != 0 ? r as IXmlLineInfo : null;
do
{
string uri = r.BaseURI;
switch (r.NodeType)
{
case XmlNodeType.Element:
{
XElement e = new XElement(eCache.Get(r.NamespaceURI).GetName(r.LocalName));
if (baseUri != null && baseUri != uri)
{
e.SetBaseUri(uri);
}
if (li != null && li.HasLineInfo())
{
e.SetLineInfo(li.LineNumber, li.LinePosition);
}
if (r.MoveToFirstAttribute())
{
do
{
XAttribute a = new XAttribute(aCache.Get(r.Prefix.Length == 0 ? string.Empty : r.NamespaceURI).GetName(r.LocalName), r.Value);
if (li != null && li.HasLineInfo())
{
a.SetLineInfo(li.LineNumber, li.LinePosition);
}
e.AppendAttributeSkipNotify(a);
} while (r.MoveToNextAttribute());
r.MoveToElement();
}
c.AddNodeSkipNotify(e);
if (!r.IsEmptyElement)
{
c = e;
if (baseUri != null)
{
baseUri = uri;
}
}
break;
}
case XmlNodeType.EndElement:
{
if (c.content == null)
{
c.content = string.Empty;
}
// Store the line info of the end element tag.
// Note that since we've got EndElement the current container must be an XElement
XElement e = c as XElement;
Debug.Assert(e != null, "EndElement received but the current container is not an element.");
if (e != null && li != null && li.HasLineInfo())
{
e.SetEndElementLineInfo(li.LineNumber, li.LinePosition);
}
if (c == this) return;
if (baseUri != null && c.HasBaseUri)
{
baseUri = c.parent.BaseUri;
}
c = c.parent;
break;
}
case XmlNodeType.Text:
case XmlNodeType.SignificantWhitespace:
case XmlNodeType.Whitespace:
if ((baseUri != null && baseUri != uri) ||
(li != null && li.HasLineInfo()))
{
n = new XText(r.Value);
}
else
{
c.AddStringSkipNotify(r.Value);
}
break;
case XmlNodeType.CDATA:
n = new XCData(r.Value);
break;
case XmlNodeType.Comment:
n = new XComment(r.Value);
break;
case XmlNodeType.ProcessingInstruction:
n = new XProcessingInstruction(r.Name, r.Value);
break;
case XmlNodeType.DocumentType:
n = new XDocumentType(r.LocalName, r.GetAttribute("PUBLIC"), r.GetAttribute("SYSTEM"), r.Value);
break;
case XmlNodeType.EntityReference:
if (!r.CanResolveEntity) throw new InvalidOperationException(SR.InvalidOperation_UnresolvedEntityReference);
r.ResolveEntity();
break;
case XmlNodeType.EndEntity:
break;
default:
throw new InvalidOperationException(SR.Format(SR.InvalidOperation_UnexpectedNodeType, r.NodeType));
}
if (n != null)
{
if (baseUri != null && baseUri != uri)
{
n.SetBaseUri(uri);
}
if (li != null && li.HasLineInfo())
{
n.SetLineInfo(li.LineNumber, li.LinePosition);
}
c.AddNodeSkipNotify(n);
n = null;
}
} while (r.Read());
}
public override void ResolveEntity()
{
this.IsCalled = true; _wrappedreader.ResolveEntity();
}
public override void ResolveEntity()
{
Console.WriteLine($"ResolveEntity");
original.ResolveEntity();
}
internal void ReadContentFrom(XmlReader r)
{
if (r.ReadState != ReadState.Interactive) throw new InvalidOperationException(SR.InvalidOperation_ExpectedInteractive);
XContainer c = this;
NamespaceCache eCache = new NamespaceCache();
NamespaceCache aCache = new NamespaceCache();
do
{
switch (r.NodeType)
{
case XmlNodeType.Element:
XElement e = new XElement(eCache.Get(r.NamespaceURI).GetName(r.LocalName));
if (r.MoveToFirstAttribute())
{
do
{
e.AppendAttributeSkipNotify(new XAttribute(aCache.Get(r.Prefix.Length == 0 ? string.Empty : r.NamespaceURI).GetName(r.LocalName), r.Value));
} while (r.MoveToNextAttribute());
r.MoveToElement();
}
c.AddNodeSkipNotify(e);
if (!r.IsEmptyElement)
{
c = e;
}
break;
case XmlNodeType.EndElement:
if (c.content == null)
{
c.content = string.Empty;
}
if (c == this) return;
c = c.parent;
break;
case XmlNodeType.Text:
case XmlNodeType.SignificantWhitespace:
case XmlNodeType.Whitespace:
c.AddStringSkipNotify(r.Value);
break;
case XmlNodeType.CDATA:
c.AddNodeSkipNotify(new XCData(r.Value));
break;
case XmlNodeType.Comment:
c.AddNodeSkipNotify(new XComment(r.Value));
break;
case XmlNodeType.ProcessingInstruction:
c.AddNodeSkipNotify(new XProcessingInstruction(r.Name, r.Value));
break;
case XmlNodeType.DocumentType:
c.AddNodeSkipNotify(new XDocumentType(r.LocalName, r.GetAttribute("PUBLIC"), r.GetAttribute("SYSTEM"), r.Value));
break;
case XmlNodeType.EntityReference:
if (!r.CanResolveEntity) throw new InvalidOperationException(SR.InvalidOperation_UnresolvedEntityReference);
r.ResolveEntity();
break;
case XmlNodeType.EndEntity:
break;
default:
throw new InvalidOperationException(SR.Format(SR.InvalidOperation_UnexpectedNodeType, r.NodeType));
}
} while (r.Read());
}
private static T Open <T>(XmlReader reader) where T : SvgDocument, new()
{
var elementStack = new Stack <SvgElement>();
bool elementEmpty;
SvgElement element = null;
SvgElement parent;
T svgDocument = null;
var elementFactory = new SvgElementFactory();
var styles = new List <ISvgNode>();
while (reader.Read())
{
try
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
// Does this element have a value or children
// (Must do this check here before we progress to another node)
elementEmpty = reader.IsEmptyElement;
// Create element
if (elementStack.Count > 0)
{
element = elementFactory.CreateElement(reader, svgDocument);
}
else
{
svgDocument = elementFactory.CreateDocument <T>(reader);
element = svgDocument;
}
// Add to the parents children
if (elementStack.Count > 0)
{
parent = elementStack.Peek();
if (parent != null && element != null)
{
parent.Children.Add(element);
parent.Nodes.Add(element);
}
}
// Push element into stack
elementStack.Push(element);
// Need to process if the element is empty
if (elementEmpty)
{
goto case XmlNodeType.EndElement;
}
break;
case XmlNodeType.EndElement:
// Pop the element out of the stack
element = elementStack.Pop();
if (element.Nodes.OfType <SvgContentNode>().Any())
{
element.Content = (from e in element.Nodes select e.Content).Aggregate((p, c) => p + c);
}
else
{
element.Nodes.Clear(); // No sense wasting the space where it isn't needed
}
var unknown = element as SvgUnknownElement;
if (unknown != null && unknown.ElementName == "style")
{
styles.Add(unknown);
}
break;
case XmlNodeType.CDATA:
case XmlNodeType.Text:
element = elementStack.Peek();
element.Nodes.Add(new SvgContentNode()
{
Content = reader.Value
});
break;
case XmlNodeType.EntityReference:
reader.ResolveEntity();
element = elementStack.Peek();
element.Nodes.Add(new SvgContentNode()
{
Content = reader.Value
});
break;
}
}
catch (Exception exc)
{
Trace.TraceError(exc.Message);
}
}
return(svgDocument);
}
public bool ReadContentFrom(XContainer rootContainer, XmlReader r, LoadOptions o)
{
XNode newNode = null;
string baseUri = r.BaseURI;
switch (r.NodeType)
{
case XmlNodeType.Element:
{
XElement e = new XElement(_eCache.Get(r.NamespaceURI).GetName(r.LocalName));
if (_baseUri != null && _baseUri != baseUri)
{
e.SetBaseUri(baseUri);
}
if (_lineInfo != null && _lineInfo.HasLineInfo())
{
e.SetLineInfo(_lineInfo.LineNumber, _lineInfo.LinePosition);
}
if (r.MoveToFirstAttribute())
{
do
{
XAttribute a = new XAttribute(_aCache.Get(r.Prefix.Length == 0 ? string.Empty : r.NamespaceURI).GetName(r.LocalName), r.Value);
if (_lineInfo != null && _lineInfo.HasLineInfo())
{
a.SetLineInfo(_lineInfo.LineNumber, _lineInfo.LinePosition);
}
e.AppendAttributeSkipNotify(a);
} while (r.MoveToNextAttribute());
r.MoveToElement();
}
_currentContainer.AddNodeSkipNotify(e);
if (!r.IsEmptyElement)
{
_currentContainer = e;
if (_baseUri != null)
{
_baseUri = baseUri;
}
}
break;
}
case XmlNodeType.EndElement:
{
if (_currentContainer.content == null)
{
_currentContainer.content = string.Empty;
}
// Store the line info of the end element tag.
// Note that since we've got EndElement the current container must be an XElement
XElement e = _currentContainer as XElement;
Debug.Assert(e != null, "EndElement received but the current container is not an element.");
if (e != null && _lineInfo != null && _lineInfo.HasLineInfo())
{
e.SetEndElementLineInfo(_lineInfo.LineNumber, _lineInfo.LinePosition);
}
if (_currentContainer == rootContainer)
{
return(false);
}
if (_baseUri != null && _currentContainer.HasBaseUri)
{
_baseUri = _currentContainer.parent.BaseUri;
}
_currentContainer = _currentContainer.parent;
break;
}
case XmlNodeType.Text:
case XmlNodeType.SignificantWhitespace:
case XmlNodeType.Whitespace:
if ((_baseUri != null && _baseUri != baseUri) ||
(_lineInfo != null && _lineInfo.HasLineInfo()))
{
newNode = new XText(r.Value);
}
else
{
_currentContainer.AddStringSkipNotify(r.Value);
}
break;
case XmlNodeType.CDATA:
newNode = new XCData(r.Value);
break;
case XmlNodeType.Comment:
newNode = new XComment(r.Value);
break;
case XmlNodeType.ProcessingInstruction:
newNode = new XProcessingInstruction(r.Name, r.Value);
break;
case XmlNodeType.DocumentType:
newNode = new XDocumentType(r.LocalName, r.GetAttribute("PUBLIC"), r.GetAttribute("SYSTEM"), r.Value);
break;
case XmlNodeType.EntityReference:
if (!r.CanResolveEntity)
{
throw new InvalidOperationException(SR.InvalidOperation_UnresolvedEntityReference);
}
r.ResolveEntity();
break;
case XmlNodeType.EndEntity:
break;
default:
throw new InvalidOperationException(SR.Format(SR.InvalidOperation_UnexpectedNodeType, r.NodeType));
}
if (newNode != null)
{
if (_baseUri != null && _baseUri != baseUri)
{
newNode.SetBaseUri(baseUri);
}
if (_lineInfo != null && _lineInfo.HasLineInfo())
{
newNode.SetLineInfo(_lineInfo.LineNumber, _lineInfo.LinePosition);
}
_currentContainer.AddNodeSkipNotify(newNode);
newNode = null;
}
return(true);
}
public bool ReadContentFrom(XContainer rootContainer, XmlReader r)
{
switch (r.NodeType)
{
case XmlNodeType.Element:
XElement e = new XElement(_eCache.Get(r.NamespaceURI).GetName(r.LocalName));
if (r.MoveToFirstAttribute())
{
do
{
e.AppendAttributeSkipNotify(new XAttribute(_aCache.Get(r.Prefix.Length == 0 ? string.Empty : r.NamespaceURI).GetName(r.LocalName), r.Value));
} while (r.MoveToNextAttribute());
r.MoveToElement();
}
_currentContainer.AddNodeSkipNotify(e);
if (!r.IsEmptyElement)
{
_currentContainer = e;
}
break;
case XmlNodeType.EndElement:
if (_currentContainer.content == null)
{
_currentContainer.content = string.Empty;
}
if (_currentContainer == rootContainer)
{
return(false);
}
_currentContainer = _currentContainer.parent;
break;
case XmlNodeType.Text:
case XmlNodeType.SignificantWhitespace:
case XmlNodeType.Whitespace:
_currentContainer.AddStringSkipNotify(r.Value);
break;
case XmlNodeType.CDATA:
_currentContainer.AddNodeSkipNotify(new XCData(r.Value));
break;
case XmlNodeType.Comment:
_currentContainer.AddNodeSkipNotify(new XComment(r.Value));
break;
case XmlNodeType.ProcessingInstruction:
_currentContainer.AddNodeSkipNotify(new XProcessingInstruction(r.Name, r.Value));
break;
case XmlNodeType.DocumentType:
_currentContainer.AddNodeSkipNotify(new XDocumentType(r.LocalName, r.GetAttribute("PUBLIC"), r.GetAttribute("SYSTEM"), r.Value));
break;
case XmlNodeType.EntityReference:
if (!r.CanResolveEntity)
{
throw new InvalidOperationException(SR.InvalidOperation_UnresolvedEntityReference);
}
r.ResolveEntity();
break;
case XmlNodeType.EndEntity:
break;
default:
throw new InvalidOperationException(SR.Format(SR.InvalidOperation_UnexpectedNodeType, r.NodeType));
}
return(true);
}
public override void ResolveEntity()
{
_currentReader.ResolveEntity();
}
internal void ReadContentFrom(XmlReader r, LoadOptions o)
{
if ((o & (LoadOptions.SetBaseUri | LoadOptions.SetLineInfo)) == 0)
{
ReadContentFrom(r);
return;
}
if (r.ReadState != ReadState.Interactive)
{
throw new InvalidOperationException(SR.InvalidOperation_ExpectedInteractive);
}
XContainer c = this;
XNode n = null;
NamespaceCache eCache = new NamespaceCache();
NamespaceCache aCache = new NamespaceCache();
string baseUri = (o & LoadOptions.SetBaseUri) != 0 ? r.BaseURI : null;
IXmlLineInfo li = (o & LoadOptions.SetLineInfo) != 0 ? r as IXmlLineInfo : null;
do
{
string uri = r.BaseURI;
switch (r.NodeType)
{
case XmlNodeType.Element:
{
XElement e = new XElement(eCache.Get(r.NamespaceURI).GetName(r.LocalName));
if (baseUri != null && baseUri != uri)
{
e.SetBaseUri(uri);
}
if (li != null && li.HasLineInfo())
{
e.SetLineInfo(li.LineNumber, li.LinePosition);
}
if (r.MoveToFirstAttribute())
{
do
{
XAttribute a = new XAttribute(aCache.Get(r.Prefix.Length == 0 ? string.Empty : r.NamespaceURI).GetName(r.LocalName), r.Value);
if (li != null && li.HasLineInfo())
{
a.SetLineInfo(li.LineNumber, li.LinePosition);
}
e.AppendAttributeSkipNotify(a);
} while (r.MoveToNextAttribute());
r.MoveToElement();
}
c.AddNodeSkipNotify(e);
if (!r.IsEmptyElement)
{
c = e;
if (baseUri != null)
{
baseUri = uri;
}
}
break;
}
case XmlNodeType.EndElement:
{
if (c.content == null)
{
c.content = string.Empty;
}
// Store the line info of the end element tag.
// Note that since we've got EndElement the current container must be an XElement
XElement e = c as XElement;
Debug.Assert(e != null, "EndElement received but the current container is not an element.");
if (e != null && li != null && li.HasLineInfo())
{
e.SetEndElementLineInfo(li.LineNumber, li.LinePosition);
}
if (c == this)
{
return;
}
if (baseUri != null && c.HasBaseUri)
{
baseUri = c.parent.BaseUri;
}
c = c.parent;
break;
}
case XmlNodeType.Text:
case XmlNodeType.SignificantWhitespace:
case XmlNodeType.Whitespace:
if ((baseUri != null && baseUri != uri) ||
(li != null && li.HasLineInfo()))
{
n = new XText(r.Value);
}
else
{
c.AddStringSkipNotify(r.Value);
}
break;
case XmlNodeType.CDATA:
n = new XCData(r.Value);
break;
case XmlNodeType.Comment:
n = new XComment(r.Value);
break;
case XmlNodeType.ProcessingInstruction:
n = new XProcessingInstruction(r.Name, r.Value);
break;
case XmlNodeType.DocumentType:
n = new XDocumentType(r.LocalName, r.GetAttribute("PUBLIC"), r.GetAttribute("SYSTEM"), r.Value);
break;
case XmlNodeType.EntityReference:
if (!r.CanResolveEntity)
{
throw new InvalidOperationException(SR.InvalidOperation_UnresolvedEntityReference);
}
r.ResolveEntity();
break;
case XmlNodeType.EndEntity:
break;
default:
throw new InvalidOperationException(SR.Format(SR.InvalidOperation_UnexpectedNodeType, r.NodeType));
}
if (n != null)
{
if (baseUri != null && baseUri != uri)
{
n.SetBaseUri(uri);
}
if (li != null && li.HasLineInfo())
{
n.SetLineInfo(li.LineNumber, li.LinePosition);
}
c.AddNodeSkipNotify(n);
n = null;
}
} while (r.Read());
}
protected void Process(CXmlBase rParentNode)
{
CXmlNode rNewNode;
while (true)
{
//We want to pop if Read() returns false, aka EOF
if (_fReadNode)
{
if (!_rXmlReader.Read())
{
DebugTrace("Read() == false");
return;
}
}
else
{
if (!_rXmlReader.ReadAttributeValue())
{
DebugTrace("ReadAttributeValue() == false");
return;
}
}
DebugTrace(_rXmlReader);
//We also want to pop if we get an EndElement or EndEntity
if (_rXmlReader.NodeType == XmlNodeType.EndElement ||
_rXmlReader.NodeType == XmlNodeType.EndEntity)
{
DebugTrace("NodeType == EndElement or EndEntity");
return;
}
rNewNode = GetNewNode(_rXmlReader);
rNewNode._nDepth = _rXmlReader.Depth;
// Test for MixedContent and set Indent if necessary
if ((rParentNode.Flags & NodeFlags.MixedContent) != 0)
{
rNewNode._eFlags |= NodeFlags.MixedContent;
// Indent is off for all new nodes
}
else
{
rNewNode._eFlags |= NodeFlags.Indent; // Turn on Indent for current Node
}
// Set all Depth 0 nodes to No Mixed Content and Indent True
if (_rXmlReader.Depth == 0)
{
rNewNode._eFlags |= NodeFlags.Indent; // Turn on Indent
rNewNode._eFlags &= ~NodeFlags.MixedContent; // Turn off MixedContent
}
rParentNode.InsertNode(rNewNode);
//Do some special stuff based on NodeType
switch (_rXmlReader.NodeType)
{
case XmlNodeType.EntityReference:
if (_eValidationMode == ValidationType.DTD)
{
_rXmlReader.ResolveEntity();
Process(rNewNode);
}
break;
case XmlNodeType.Element:
if (_rXmlReader.MoveToFirstAttribute())
{
do
{
CXmlAttribute rNewAttribute = new CXmlAttribute(_rXmlReader);
rNewNode.AddAttribute(rNewAttribute);
if (_fExpandAttributeValues)
{
DebugTrace("Attribute: " + _rXmlReader.Name);
_fReadNode = false;
Process(rNewAttribute);
_fReadNode = true;
}
else
{
CXmlNode rValueNode = new CXmlNode("", "", XmlNodeType.Text);
rValueNode._eFlags = _eDefaultFlags | NodeFlags.HasValue;
rValueNode._strValue = _rXmlReader.Value;
DebugTrace(" Value=" + rValueNode.Value, _rXmlReader.Depth + 1);
rNewAttribute.InsertNode(rValueNode);
}
} while (_rXmlReader.MoveToNextAttribute());
}
if ((rNewNode.Flags & NodeFlags.EmptyElement) == 0)
{
Process(rNewNode);
}
break;
case XmlNodeType.XmlDeclaration:
if (_rXmlReader is XmlTextReader)
{
_eEncoding = ((XmlTextReader)_rXmlReader).Encoding;
}
#pragma warning disable 0618
else if (_rXmlReader is XmlValidatingReader)
{
_eEncoding = ((XmlValidatingReader)_rXmlReader).Encoding;
}
#pragma warning restore 0618
else
{
string strValue = rNewNode.NodeValue;
int nPos = strValue.IndexOf("encoding");
if (nPos != -1)
{
int nEnd;
nPos = strValue.IndexOf("=", nPos); //Find the = sign
nEnd = strValue.IndexOf("\"", nPos) + 1; //Find the next " character
nPos = strValue.IndexOf("'", nPos) + 1; //Find the next ' character
if (nEnd == 0 || (nPos < nEnd && nPos > 0)) //Pick the one that's closer to the = sign
{
nEnd = strValue.IndexOf("'", nPos);
}
else
{
nPos = nEnd;
nEnd = strValue.IndexOf("\"", nPos);
}
string sEncodeName = strValue.Substring(nPos, nEnd - nPos);
DebugTrace("XMLDecl contains encoding " + sEncodeName);
if (sEncodeName.ToUpper() == "UCS-2")
{
sEncodeName = "unicode";
}
_eEncoding = System.Text.Encoding.GetEncoding(sEncodeName);
}
}
break;
case XmlNodeType.ProcessingInstruction:
break;
case XmlNodeType.Text:
if (!_fReadNode)
{
rNewNode._eFlags = _eDefaultFlags | NodeFlags.AttributeTextNode;
}
rNewNode._eFlags |= NodeFlags.MixedContent; // turn on Mixed Content for current node
rNewNode._eFlags &= ~NodeFlags.Indent; // turn off Indent for current node
rParentNode._eFlags |= NodeFlags.MixedContent; // turn on Mixed Content for Parent Node
break;
case XmlNodeType.Whitespace:
case XmlNodeType.SignificantWhitespace:
case XmlNodeType.CDATA:
rNewNode._eFlags |= NodeFlags.MixedContent; // turn on Mixed Content for current node
rNewNode._eFlags &= ~NodeFlags.Indent; // turn off Indent for current node
rParentNode._eFlags |= NodeFlags.MixedContent; // turn on Mixed Content for Parent Node
break;
case XmlNodeType.Comment:
case XmlNodeType.Notation:
break;
case XmlNodeType.DocumentType:
if (_rXmlReader.MoveToFirstAttribute())
{
do
{
CXmlAttribute rNewAttribute = new CXmlAttribute(_rXmlReader);
rNewNode.AddAttribute(rNewAttribute);
CXmlNode rValueNode = new CXmlNode(_rXmlReader);
rValueNode._strValue = _rXmlReader.Value;
rNewAttribute.InsertNode(rValueNode);
} while (_rXmlReader.MoveToNextAttribute());
}
break;
default:
_output.WriteLine("UNHANDLED TYPE, " + _rXmlReader.NodeType.ToString() + " IN Process()!");
break;
}
}
}
internal void ReadContentFrom(XmlReader r)
{
if (r.ReadState != ReadState.Interactive)
{
throw new InvalidOperationException(SR.InvalidOperation_ExpectedInteractive);
}
XContainer c = this;
NamespaceCache eCache = new NamespaceCache();
NamespaceCache aCache = new NamespaceCache();
do
{
switch (r.NodeType)
{
case XmlNodeType.Element:
XElement e = new XElement(eCache.Get(r.NamespaceURI).GetName(r.LocalName));
if (r.MoveToFirstAttribute())
{
do
{
e.AppendAttributeSkipNotify(new XAttribute(aCache.Get(r.Prefix.Length == 0 ? string.Empty : r.NamespaceURI).GetName(r.LocalName), r.Value));
} while (r.MoveToNextAttribute());
r.MoveToElement();
}
c.AddNodeSkipNotify(e);
if (!r.IsEmptyElement)
{
c = e;
}
break;
case XmlNodeType.EndElement:
if (c.content == null)
{
c.content = string.Empty;
}
if (c == this)
{
return;
}
c = c.parent;
break;
case XmlNodeType.Text:
case XmlNodeType.SignificantWhitespace:
case XmlNodeType.Whitespace:
c.AddStringSkipNotify(r.Value);
break;
case XmlNodeType.CDATA:
c.AddNodeSkipNotify(new XCData(r.Value));
break;
case XmlNodeType.Comment:
c.AddNodeSkipNotify(new XComment(r.Value));
break;
case XmlNodeType.ProcessingInstruction:
c.AddNodeSkipNotify(new XProcessingInstruction(r.Name, r.Value));
break;
case XmlNodeType.DocumentType:
c.AddNodeSkipNotify(new XDocumentType(r.LocalName, r.GetAttribute("PUBLIC"), r.GetAttribute("SYSTEM"), r.Value));
break;
case XmlNodeType.EntityReference:
if (!r.CanResolveEntity)
{
throw new InvalidOperationException(SR.InvalidOperation_UnresolvedEntityReference);
}
r.ResolveEntity();
break;
case XmlNodeType.EndEntity:
break;
default:
throw new InvalidOperationException(SR.Format(SR.InvalidOperation_UnexpectedNodeType, r.NodeType));
}
} while (r.Read());
}
public override void ResolveEntity() => _base.ResolveEntity();
private void LoadDocument()
{
bool preserveWhitespace = false;
XmlReader r = this.reader;
XmlNode parent = this.doc;
XmlElement element;
while (r.Read())
{
XmlNode node = null;
switch (r.NodeType)
{
case XmlNodeType.Element:
bool fEmptyElement = r.IsEmptyElement;
element = doc.CreateElement(r.Prefix, r.LocalName, r.NamespaceURI);
AddToTable(element);
element.IsEmpty = fEmptyElement;
ReadAttributes(r, element);
if (!fEmptyElement)
{
parent.AppendChild(element);
parent = element;
continue;
}
node = element;
if (!namespaceList.Contains(node.NamespaceURI))
{
namespaceList.Add(node.NamespaceURI);
}
break;
case XmlNodeType.EndElement:
if (parent.ParentNode == null)
{
// syntax error in document.
IXmlLineInfo li = (IXmlLineInfo)r;
throw new XmlException(string.Format("Unexpected end tag '{0}' at line {1} column {2}",
r.LocalName, li.LineNumber, li.LinePosition), null, li.LineNumber, li.LinePosition);
}
parent = parent.ParentNode;
continue;
case XmlNodeType.EntityReference:
if (r.CanResolveEntity)
{
r.ResolveEntity();
}
continue;
case XmlNodeType.EndEntity:
continue;
case XmlNodeType.Attribute:
node = LoadAttributeNode();
if (!namespaceList.Contains(node.NamespaceURI))
{
namespaceList.Add(node.NamespaceURI);
}
break;
case XmlNodeType.Text:
node = doc.CreateTextNode(r.Value);
AddToTable(node);
break;
case XmlNodeType.SignificantWhitespace:
node = doc.CreateSignificantWhitespace(r.Value);
AddToTable(node);
break;
case XmlNodeType.Whitespace:
if (preserveWhitespace)
{
node = doc.CreateWhitespace(r.Value);
AddToTable(node);
break;
}
else
{
continue;
}
case XmlNodeType.CDATA:
node = doc.CreateCDataSection(r.Value);
AddToTable(node);
break;
case XmlNodeType.XmlDeclaration:
node = LoadDeclarationNode();
break;
case XmlNodeType.ProcessingInstruction:
node = doc.CreateProcessingInstruction(r.Name, r.Value);
AddToTable(node);
break;
case XmlNodeType.Comment:
node = doc.CreateComment(r.Value);
AddToTable(node);
break;
case XmlNodeType.DocumentType:
continue;
default:
UnexpectedNodeType(r.NodeType);
break;
}
Debug.Assert(node != null);
Debug.Assert(parent != null);
if (parent != null)
{
parent.AppendChild(node);
}
}
}
private static T Open <T>(XmlReader reader) where T : SvgDocument, new()
{
if (!SkipGdiPlusCapabilityCheck)
{
EnsureSystemIsGdiPlusCapable(); //Validate whether the GDI+ can be loaded, this will yield an exception if not
}
var elementStack = new Stack <SvgElement>();
bool elementEmpty;
SvgElement element = null;
SvgElement parent;
T svgDocument = null;
var elementFactory = new SvgElementFactory();
var styles = new List <ISvgNode>();
while (reader.Read())
{
try
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
// Does this element have a value or children
// (Must do this check here before we progress to another node)
elementEmpty = reader.IsEmptyElement;
// Create element
if (elementStack.Count > 0)
{
element = elementFactory.CreateElement(reader, svgDocument);
}
else
{
svgDocument = elementFactory.CreateDocument <T>(reader);
element = svgDocument;
}
// Add to the parents children
if (elementStack.Count > 0)
{
parent = elementStack.Peek();
if (parent != null && element != null)
{
parent.Children.Add(element);
parent.Nodes.Add(element);
}
}
// Push element into stack
elementStack.Push(element);
// Need to process if the element is empty
if (elementEmpty)
{
goto case XmlNodeType.EndElement;
}
break;
case XmlNodeType.EndElement:
// Pop the element out of the stack
element = elementStack.Pop();
if (element.Nodes.OfType <SvgContentNode>().Any())
{
element.Content = (from e in element.Nodes select e.Content).Aggregate((p, c) => p + c);
}
else
{
element.Nodes.Clear(); // No sense wasting the space where it isn't needed
}
var unknown = element as SvgUnknownElement;
if (unknown != null && unknown.ElementName == "style")
{
styles.Add(unknown);
}
break;
case XmlNodeType.CDATA:
case XmlNodeType.Text:
case XmlNodeType.SignificantWhitespace:
element = elementStack.Peek();
element.Nodes.Add(new SvgContentNode()
{
Content = reader.Value
});
break;
case XmlNodeType.EntityReference:
reader.ResolveEntity();
element = elementStack.Peek();
element.Nodes.Add(new SvgContentNode()
{
Content = reader.Value
});
break;
}
}
catch (Exception exc)
{
Trace.TraceError(exc.Message);
}
}
if (styles.Any())
{
var cssTotal = styles.Select((s) => s.Content).Aggregate((p, c) => p + Environment.NewLine + c);
var cssParser = new Parser();
var sheet = cssParser.Parse(cssTotal);
foreach (var rule in sheet.StyleRules)
{
try
{
var rootNode = new NonSvgElement();
rootNode.Children.Add(svgDocument);
var elemsToStyle = rootNode.QuerySelectorAll(rule.Selector.ToString(), elementFactory);
foreach (var elem in elemsToStyle)
{
foreach (var decl in rule.Declarations)
{
elem.AddStyle(decl.Name, decl.Term.ToString(), rule.Selector.GetSpecificity());
}
}
}
catch (Exception ex)
{
Trace.TraceWarning(ex.Message);
}
}
}
svgDocument?.FlushStyles(true);
return(svgDocument);
}
XmlNode ReadNodeCore(XmlReader reader)
{
switch (reader.ReadState)
{
case ReadState.Interactive:
break;
case ReadState.Initial:
#if NET_2_0
if (reader.SchemaInfo != null)
{
SchemaInfo = reader.SchemaInfo;
}
#endif
reader.Read();
break;
default:
return(null);
}
XmlNode n;
switch (reader.NodeType)
{
case XmlNodeType.Attribute:
string localName = reader.LocalName;
string ns = reader.NamespaceURI;
n = ReadAttributeNode(reader);
// Keep the current reader position on attribute.
reader.MoveToAttribute(localName, ns);
return(n);
case XmlNodeType.CDATA:
n = CreateCDataSection(reader.Value);
break;
case XmlNodeType.Comment:
n = CreateComment(reader.Value);
break;
case XmlNodeType.Element:
XmlElement element = CreateElement(reader.Prefix, reader.LocalName, reader.NamespaceURI, reader.NameTable == this.NameTable);
#if NET_2_0
if (reader.SchemaInfo != null)
{
SchemaInfo = reader.SchemaInfo;
}
#endif
element.IsEmpty = reader.IsEmptyElement;
// set the element's attributes.
for (int i = 0; i < reader.AttributeCount; i++)
{
reader.MoveToAttribute(i);
element.SetAttributeNode(
ReadAttributeNode(reader));
reader.MoveToElement();
}
// FIXME: the code below should be fine and
// in some XmlReaders it is much faster, but
// caused some breakage in sys.data test.
/*
* if (reader.MoveToFirstAttribute ()) {
* do {
* element.SetAttributeNode (ReadAttributeNode (reader));
* } while (reader.MoveToNextAttribute ());
* reader.MoveToElement ();
* }
*/
reader.MoveToElement();
int depth = reader.Depth;
if (reader.IsEmptyElement)
{
n = element;
break;
}
reader.Read();
while (reader.Depth > depth)
{
n = ReadNodeCore(reader);
if (preserveWhitespace || n.NodeType != XmlNodeType.Whitespace)
{
element.AppendChild(n, false);
}
}
n = element;
break;
case XmlNodeType.ProcessingInstruction:
n = CreateProcessingInstruction(reader.Name, reader.Value);
break;
case XmlNodeType.Text:
n = CreateTextNode(reader.Value);
break;
case XmlNodeType.XmlDeclaration:
n = CreateXmlDeclaration("1.0", String.Empty, String.Empty);
n.Value = reader.Value;
break;
case XmlNodeType.DocumentType:
DTDObjectModel dtd = null;
IHasXmlParserContext ctxReader = reader as IHasXmlParserContext;
if (ctxReader != null)
{
dtd = ctxReader.ParserContext.Dtd;
}
if (dtd != null)
{
n = CreateDocumentType(dtd);
}
else
{
n = CreateDocumentType(reader.Name, reader ["PUBLIC"], reader ["SYSTEM"], reader.Value);
}
break;
case XmlNodeType.EntityReference:
if (this.loadMode && this.DocumentType != null &&
DocumentType.Entities.GetNamedItem(reader.Name) == null)
{
throw new XmlException("Reference to undeclared entity was found.");
}
n = CreateEntityReference(reader.Name);
// IF argument XmlReader can resolve entity,
// ReadNode() also fills children _from it_.
// In this case, it is not from doctype node.
// (it is kind of sucky design, but it happens
// anyways when we modify doctype node).
//
// It does not happen when !CanResolveEntity.
// (In such case AppendChild() will resolve
// entity content, as XmlEntityReference does.)
if (reader.CanResolveEntity)
{
reader.ResolveEntity();
reader.Read();
for (XmlNode child; reader.NodeType != XmlNodeType.EndEntity && (child = ReadNode(reader)) != null;)
{
n.InsertBefore(child, null, false, false);
}
}
break;
case XmlNodeType.SignificantWhitespace:
n = CreateSignificantWhitespace(reader.Value);
break;
case XmlNodeType.Whitespace:
n = CreateWhitespace(reader.Value);
break;
case XmlNodeType.None:
return(null);
default:
// No idea why MS does throw NullReferenceException ;-P
throw new NullReferenceException("Unexpected node type " + reader.NodeType + ".");
}
reader.Read();
return(n);
}
public override void ResolveEntity()
{
_wrappedReader.ResolveEntity();
}
/// <summary>
/// Read an XNode from the given XmlReader and LineInfo object. If available, line info will be added to XElement.
/// This technique is adapted from here: http://blogs.msdn.com/b/mikechampion/archive/2006/09/10/748408.aspx
/// </summary>
/// <param name="reader">The XmlReader to read from</param>
/// <param name="lineInfo">This should be <paramref name="reader"/> cast as an <see cref="IXmlLineInfo"/></param>
/// <returns>an XNode with line information if present</returns>
/// <seealso cref="XNode.ReadFrom">This function replaces XNode.ReadFrom</seealso>
public static XNode ReadWithLineInfo(XmlReader reader, IXmlLineInfo lineInfo)
{
XNode node = null;
XElement parent = null;
do
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
// create a new element with the given name
XElement element = new XElement(XName.Get(reader.LocalName, reader.NamespaceURI));
// add attributes to the element
if (reader.MoveToFirstAttribute())
{
do
{
// Compound documents created with older versions of ABB.SrcML left out some namespaces
// this causes an "xmlns" attribute to be added to any names not in the default (SRC) namespace
// to avoid an ArgumentException thrown by element.Add in this case, just don't add these
if (!(reader.LocalName == "xmlns" && reader.NamespaceURI == "http://www.w3.org/2000/xmlns/"))
{
element.Add(new XAttribute(XName.Get(reader.LocalName, reader.NamespaceURI), reader.Value));
}
} while (reader.MoveToNextAttribute());
reader.MoveToElement();
}
// add a ABB.SrcML.LineInfo annotation to the element if line information is present.
if (lineInfo.HasLineInfo())
{
element.SetLineInfo(new LineInfo(lineInfo.LineNumber, lineInfo.LinePosition));
}
// if the reader is not empty, we have to go and get all of the children and add them.
// otherwise, we can jsut set this to node.
if (!reader.IsEmptyElement)
{
if (null != parent)
{
parent.Add(element);
}
parent = element;
continue;
}
else
{
node = element;
}
break;
case XmlNodeType.EndElement:
// process the EndElement
if (null == parent)
{
return(null);
}
if (parent.IsEmpty)
{
parent.Add(string.Empty);
}
if (parent.Parent == null)
{
return(parent);
}
parent = parent.Parent;
continue;
case XmlNodeType.Text:
case XmlNodeType.SignificantWhitespace:
case XmlNodeType.Whitespace:
node = new XText(reader.Value);
break;
case XmlNodeType.CDATA:
node = new XCData(reader.Value);
break;
case XmlNodeType.Comment:
node = new XComment(reader.Value);
break;
case XmlNodeType.ProcessingInstruction:
node = new XProcessingInstruction(reader.Name, reader.Value);
break;
case XmlNodeType.DocumentType:
node = new XDocumentType(reader.LocalName, reader.GetAttribute("PUBLIC"), reader.GetAttribute("SYSTEM"), reader.Value);
break;
case XmlNodeType.EntityReference:
reader.ResolveEntity();
continue;
case XmlNodeType.XmlDeclaration:
case XmlNodeType.EndEntity:
continue;
default:
throw new InvalidOperationException();
}
if (null == parent)
{
return(node);
}
parent.Add(node);
} while (reader.Read());
return(null);
}
private static T Open <T>(XmlReader reader) where T : SvgDocument, new()
{
var elementStack = new Stack <SvgElement>();
bool elementEmpty;
SvgElement element = null;
SvgElement parent;
T svgDocument = null;
var styles = new List <ISvgNode>();
while (reader.Read())
{
try
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
// Does this element have a value or children
// (Must do this check here before we progress to another node)
elementEmpty = reader.IsEmptyElement;
// Create element
if (elementStack.Count > 0)
{
element = SvgElementFactory.CreateElement(reader, svgDocument);
}
else
{
svgDocument = SvgElementFactory.CreateDocument <T>(reader);
element = svgDocument;
}
// Add to the parents children
if (elementStack.Count > 0)
{
parent = elementStack.Peek();
if (parent != null && element != null)
{
parent.Children.Add(element);
parent.Nodes.Add(element);
}
}
// Push element into stack
elementStack.Push(element);
// Need to process if the element is empty
if (elementEmpty)
{
goto case XmlNodeType.EndElement;
}
break;
case XmlNodeType.EndElement:
// Pop the element out of the stack
element = elementStack.Pop();
if (element.Nodes.OfType <SvgContentNode>().Any())
{
element.Content = (from e in element.Nodes select e.Content).Aggregate((p, c) => p + c);
}
else
{
element.Nodes.Clear(); // No sense wasting the space where it isn't needed
}
var unknown = element as SvgUnknownElement;
if (unknown != null && unknown.ElementName == "style")
{
styles.Add(unknown);
}
break;
case XmlNodeType.CDATA:
case XmlNodeType.Text:
element = elementStack.Peek();
element.Nodes.Add(new SvgContentNode()
{
Content = reader.Value
});
break;
case XmlNodeType.EntityReference:
reader.ResolveEntity();
element = elementStack.Peek();
element.Nodes.Add(new SvgContentNode()
{
Content = reader.Value
});
break;
}
}
catch (Exception exc)
{
Trace.TraceError(exc.Message);
}
}
if (styles.Any())
{
var cssTotal = styles.Select((s) => s.Content).Aggregate((p, c) => p + Environment.NewLine + c);
var cssParser = new Parser();
var sheet = cssParser.Parse(cssTotal);
AggregateSelectorList aggList;
IEnumerable <BaseSelector> selectors;
IEnumerable <SvgElement> elemsToStyle;
foreach (var rule in sheet.StyleRules)
{
aggList = rule.Selector as AggregateSelectorList;
if (aggList != null && aggList.Delimiter == ",")
{
selectors = aggList;
}
else
{
selectors = Enumerable.Repeat(rule.Selector, 1);
}
foreach (var selector in selectors)
{
elemsToStyle = svgDocument.QuerySelectorAll(rule.Selector.ToString());
foreach (var elem in elemsToStyle)
{
foreach (var decl in rule.Declarations)
{
elem.AddStyle(decl.Name, decl.Term.ToString(), rule.Selector.GetSpecificity());
}
}
}
}
}
if (svgDocument != null)
{
FlushStyles(svgDocument);
}
return(svgDocument);
}
public override void ResolveEntity()
{
m_source.ResolveEntity();
}
public override void ResolveEntity()
{
CheckAsync();
_coreReader.ResolveEntity();
}
public override void ResolveEntity()
{
_baseReader.ResolveEntity();
}
public override void ResolveEntity()
{
_innerReader.ResolveEntity();
}
public override void ResolveEntity()
{
_reader.ResolveEntity();
_logger.WriteLine("ResolveEntity()");
}
bool ReadPrologUntil(XElement source, XName match)
{
if (_reader.ReadState != ReadState.Interactive)
{
throw new InvalidOperationException("The reader state should be Interactive.");
}
do
{
switch (_reader.NodeType)
{
case XmlNodeType.Element:
XName name = XNamespace.Get(_reader.NamespaceURI).GetName(_reader.LocalName);
if (name == match)
{
return(true);
}
XElement e = new XElement(name);
if (_reader.MoveToFirstAttribute())
{
do
{
XNamespace ns = _reader.Prefix.Length == 0 ? XNamespace.None : XNamespace.Get(_reader.NamespaceURI);
e.Add(new XAttribute(ns.GetName(_reader.LocalName), _reader.Value));
} while (_reader.MoveToNextAttribute());
_reader.MoveToElement();
}
source.Add(e);
if (!_reader.IsEmptyElement)
{
_reader.Read();
ReadContent(e);
}
break;
case XmlNodeType.EndElement:
return(false);
case XmlNodeType.Text:
case XmlNodeType.SignificantWhitespace:
case XmlNodeType.Whitespace:
case XmlNodeType.CDATA:
case XmlNodeType.Comment:
case XmlNodeType.ProcessingInstruction:
case XmlNodeType.DocumentType:
break;
case XmlNodeType.EntityReference:
if (!_reader.CanResolveEntity)
{
throw new InvalidOperationException("The reader cannot resolve entity references.");
}
_reader.ResolveEntity();
break;
case XmlNodeType.EndEntity:
break;
default:
throw new InvalidOperationException(string.Format("The reader should not be on a node of type '{0}'.", _reader.NodeType));
}
} while (_reader.Read());
return(false);
}
public override void ResolveEntity()
{
validatingReader.ResolveEntity();
}
