internal void LoadFromReader(XmlReader reader, XmlSpace space)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
IXmlLineInfo lineInfo = reader as IXmlLineInfo;
if ((lineInfo == null) || !lineInfo.HasLineInfo())
{
lineInfo = null;
}
this.hasLineInfo = lineInfo != null;
this.nameTable = reader.NameTable;
XPathDocumentBuilder builder = new XPathDocumentBuilder(this, lineInfo, reader.BaseURI, LoadFlags.None);
try
{
bool isEmptyElement;
string str2;
bool flag = reader.ReadState == ReadState.Initial;
int depth = reader.Depth;
string str = this.nameTable.Get("http://www.w3.org/2000/xmlns/");
if (flag && !reader.Read())
{
return;
}
Label_007D:
if (!flag && (reader.Depth < depth))
{
return;
}
switch (reader.NodeType)
{
case XmlNodeType.Element:
isEmptyElement = reader.IsEmptyElement;
builder.WriteStartElement(reader.Prefix, reader.LocalName, reader.NamespaceURI, reader.BaseURI);
goto Label_017B;
case XmlNodeType.Text:
case XmlNodeType.CDATA:
builder.WriteString(reader.Value, TextBlockType.Text);
goto Label_022B;
case XmlNodeType.EntityReference:
reader.ResolveEntity();
goto Label_022B;
case XmlNodeType.ProcessingInstruction:
builder.WriteProcessingInstruction(reader.LocalName, reader.Value, reader.BaseURI);
goto Label_022B;
case XmlNodeType.Comment:
builder.WriteComment(reader.Value);
goto Label_022B;
case XmlNodeType.DocumentType:
{
IDtdInfo dtdInfo = reader.DtdInfo;
if (dtdInfo != null)
{
builder.CreateIdTables(dtdInfo);
}
goto Label_022B;
}
case XmlNodeType.Whitespace:
goto Label_01C9;
case XmlNodeType.SignificantWhitespace:
if (reader.XmlSpace != XmlSpace.Preserve)
{
goto Label_01C9;
}
builder.WriteString(reader.Value, TextBlockType.SignificantWhitespace);
goto Label_022B;
case XmlNodeType.EndElement:
builder.WriteEndElement(false);
goto Label_022B;
default:
goto Label_022B;
}
Label_0113:
str2 = reader.NamespaceURI;
if (str2 == str)
{
if (reader.Prefix.Length == 0)
{
builder.WriteNamespaceDeclaration(string.Empty, reader.Value);
}
else
{
builder.WriteNamespaceDeclaration(reader.LocalName, reader.Value);
}
}
else
{
builder.WriteStartAttribute(reader.Prefix, reader.LocalName, str2);
builder.WriteString(reader.Value, TextBlockType.Text);
builder.WriteEndAttribute();
}
Label_017B:
if (reader.MoveToNextAttribute())
{
goto Label_0113;
}
if (isEmptyElement)
{
builder.WriteEndElement(true);
}
goto Label_022B;
Label_01C9:
if ((space == XmlSpace.Preserve) && (!flag || (reader.Depth != 0)))
{
builder.WriteString(reader.Value, TextBlockType.Whitespace);
}
Label_022B:
if (reader.Read())
{
goto Label_007D;
}
}
finally
{
builder.Close();
}
}
public override void ResolveEntity()
{
reader.ResolveEntity();
}
private string fromEntity(XmlReader xr)
{
xr.Read();
if (xr.NodeType == XmlNodeType.EntityReference) {
string name = xr.Name;
if (!entities.ContainsKey(name)) {
xr.ResolveEntity();
entities.Add(name, xr.ReadString());
}
return name;
} else {
throw new MyException("Wtf?" + xr.NodeType.ToString() + ": " + xr.Name + ": " + xr.ReadString());
}
}
public override void ResolveEntity()
{
CheckAsync();
_coreReader.ResolveEntity();
}
// Load elements from a reader
// Must be called on the DOM object
int ReadChildNodes(XmlReader reader, int parent, int parentNS)
{
Fx.Assert(reader != null, "Reader cannot be null");
// Loop over all nodes being surfaced
int n = NullIndex;
do
{
// PERF, [....], reorder cases so more common ones are earlier
switch (reader.NodeType)
{
case XmlNodeType.Element:
n = NewNode();
this.nodes[n].type = XPathNodeType.Element;
this.nodes[n].prefix = reader.Prefix;
this.nodes[n].name = reader.LocalName;
this.nodes[n].ns = reader.NamespaceURI;
this.nodes[n].firstNamespace = parentNS;
this.nodes[n].baseUri = reader.BaseURI;
this.nodes[n].xmlLang = reader.XmlLang;
// Empty elements don't surface closing tags so they need to be handled differently
if (!reader.IsEmptyElement)
{
ReadAttributes(n, reader);
reader.Read();
ReadChildNodes(reader, n, this.nodes[n].firstNamespace);
}
else
{
ReadAttributes(n, reader);
this.nodes[n].empty = true;
}
AddChild(parent, n);
break;
case XmlNodeType.Comment:
n = NewNode();
this.nodes[n].type = XPathNodeType.Comment;
this.nodes[n].val = reader.Value;
this.nodes[n].baseUri = reader.BaseURI;
this.nodes[n].xmlLang = reader.XmlLang;
AddChild(parent, n);
break;
case XmlNodeType.ProcessingInstruction:
n = NewNode();
this.nodes[n].type = XPathNodeType.ProcessingInstruction;
this.nodes[n].name = reader.LocalName;
this.nodes[n].val = reader.Value;
this.nodes[n].baseUri = reader.BaseURI;
this.nodes[n].xmlLang = reader.XmlLang;
AddChild(parent, n);
break;
case XmlNodeType.SignificantWhitespace:
if (reader.XmlSpace == XmlSpace.Preserve)
{
// If we're preserving whitespace, try to append it to a text node instead
// of creating a new node
n = LastChild(parent);
if (n != NullIndex && (this.nodes[n].type == XPathNodeType.Text ||
this.nodes[n].type == XPathNodeType.Whitespace ||
this.nodes[n].type == XPathNodeType.SignificantWhitespace))
{
this.nodes[n].val = this.nodes[n].val + reader.Value;
}
else
{
n = NewNode();
this.nodes[n].type = XPathNodeType.SignificantWhitespace;
this.nodes[n].val = reader.Value;
this.nodes[n].baseUri = reader.BaseURI;
this.nodes[n].xmlLang = reader.XmlLang;
AddChild(parent, n);
}
}
else
{
goto case XmlNodeType.Whitespace;
}
break;
case XmlNodeType.Whitespace:
if (this.space == XmlSpace.Preserve)
{
// If we're preserving whitespace, try to append it to a text node instead
// of creating a new node
n = LastChild(parent);
if (n != NullIndex && (this.nodes[n].type == XPathNodeType.Text ||
this.nodes[n].type == XPathNodeType.Whitespace ||
this.nodes[n].type == XPathNodeType.SignificantWhitespace))
{
this.nodes[n].val = this.nodes[n].val + reader.Value;
}
else
{
n = NewNode();
this.nodes[n].type = XPathNodeType.Whitespace;
this.nodes[n].val = reader.Value;
this.nodes[n].baseUri = reader.BaseURI;
this.nodes[n].xmlLang = reader.XmlLang;
AddChild(parent, n);
}
}
break;
case XmlNodeType.CDATA:
case XmlNodeType.Text:
// Try to append it to a text node instead of creating a new node
n = LastChild(parent);
if (n == NullIndex || (this.nodes[n].type != XPathNodeType.Text &&
this.nodes[n].type != XPathNodeType.Whitespace &&
this.nodes[n].type != XPathNodeType.SignificantWhitespace))
{
n = NewNode();
this.nodes[n].baseUri = reader.BaseURI;
this.nodes[n].xmlLang = reader.XmlLang;
AddChild(parent, n);
}
this.nodes[n].type = XPathNodeType.Text;
this.nodes[n].val = reader.Value;
break;
case XmlNodeType.EntityReference:
reader.ResolveEntity();
reader.Read();
ReadChildNodes(reader, parent, parentNS);
break;
case XmlNodeType.EndEntity:
case XmlNodeType.EndElement:
case XmlNodeType.None:
return n;
case XmlNodeType.DocumentType:
break;
case XmlNodeType.XmlDeclaration:
default:
break;
}
} while (reader.Read());
return n;
}
XmlNode ReadNodeCore(XmlReader reader)
{
switch (reader.ReadState)
{
case ReadState.Interactive:
break;
case ReadState.Initial:
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);
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:
#if NOT_PFX
DTDObjectModel dtd = null;
IHasXmlParserContext ctxReader = reader as IHasXmlParserContext;
#endif
#if NOT_PFX
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;
#endif
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);
}
/// <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;
this.hasLineInfo = (lineInfo != null);
this.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) this.nameTable.Get(string.Empty) == (object) string.Empty, "NameTable must contain atomized string.Empty");
xmlnsUri = this.nameTable.Get("http://www.w3.org/2000/xmlns/");
// 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:
Debug.Assert(reader.XmlSpace != XmlSpace.Preserve);
// 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:
// Create ID tables
SchemaInfo info = XmlReader.GetDtdSchemaInfo(reader);
if (info != null)
builder.CreateIdTables(info);
break;
case XmlNodeType.EndEntity:
case XmlNodeType.None:
case XmlNodeType.XmlDeclaration:
break;
}
}
while (reader.Read());
}
finally {
builder.Close();
}
}
internal void ReadContentFrom(XmlReader r, LoadOptions o)
{
if ((o & (LoadOptions.SetLineInfo | LoadOptions.SetBaseUri)) == LoadOptions.None)
{
this.ReadContentFrom(r);
}
else
{
if (r.ReadState != System.Xml.ReadState.Interactive)
{
throw new InvalidOperationException(System.Xml.Linq.Res.GetString("InvalidOperation_ExpectedInteractive"));
}
XContainer parent = this;
XNode n = null;
NamespaceCache cache = new NamespaceCache();
NamespaceCache cache2 = new NamespaceCache();
string baseUri = ((o & LoadOptions.SetBaseUri) != LoadOptions.None) ? r.BaseURI : null;
IXmlLineInfo info = ((o & LoadOptions.SetLineInfo) != LoadOptions.None) ? (r as IXmlLineInfo) : null;
do
{
string baseURI = r.BaseURI;
switch (r.NodeType)
{
case XmlNodeType.Element:
{
XElement element = new XElement(cache.Get(r.NamespaceURI).GetName(r.LocalName));
if ((baseUri != null) && (baseUri != baseURI))
{
element.SetBaseUri(baseURI);
}
if ((info != null) && info.HasLineInfo())
{
element.SetLineInfo(info.LineNumber, info.LinePosition);
}
if (r.MoveToFirstAttribute())
{
do
{
XAttribute a = new XAttribute(cache2.Get((r.Prefix.Length == 0) ? string.Empty : r.NamespaceURI).GetName(r.LocalName), r.Value);
if ((info != null) && info.HasLineInfo())
{
a.SetLineInfo(info.LineNumber, info.LinePosition);
}
element.AppendAttributeSkipNotify(a);
}
while (r.MoveToNextAttribute());
r.MoveToElement();
}
parent.AddNodeSkipNotify(element);
if (!r.IsEmptyElement)
{
parent = element;
if (baseUri != null)
{
baseUri = baseURI;
}
}
break;
}
case XmlNodeType.Text:
case XmlNodeType.Whitespace:
case XmlNodeType.SignificantWhitespace:
if (((baseUri == null) || (baseUri == baseURI)) && ((info == null) || !info.HasLineInfo()))
{
parent.AddStringSkipNotify(r.Value);
}
else
{
n = new XText(r.Value);
}
break;
case XmlNodeType.CDATA:
n = new XCData(r.Value);
break;
case XmlNodeType.EntityReference:
if (!r.CanResolveEntity)
{
throw new InvalidOperationException(System.Xml.Linq.Res.GetString("InvalidOperation_UnresolvedEntityReference"));
}
r.ResolveEntity();
break;
case XmlNodeType.ProcessingInstruction:
n = new XProcessingInstruction(r.Name, r.Value);
break;
case XmlNodeType.Comment:
n = new XComment(r.Value);
break;
case XmlNodeType.DocumentType:
n = new XDocumentType(r.LocalName, r.GetAttribute("PUBLIC"), r.GetAttribute("SYSTEM"), r.Value, r.DtdInfo);
break;
case XmlNodeType.EndElement:
{
if (parent.content == null)
{
parent.content = string.Empty;
}
XElement element2 = parent as XElement;
if (((element2 != null) && (info != null)) && info.HasLineInfo())
{
element2.SetEndElementLineInfo(info.LineNumber, info.LinePosition);
}
if (parent == this)
{
return;
}
if ((baseUri != null) && parent.HasBaseUri)
{
baseUri = parent.parent.BaseUri;
}
parent = parent.parent;
break;
}
case XmlNodeType.EndEntity:
break;
default:
throw new InvalidOperationException(System.Xml.Linq.Res.GetString("InvalidOperation_UnexpectedNodeType", new object[] { r.NodeType }));
}
if (n != null)
{
if ((baseUri != null) && (baseUri != baseURI))
{
n.SetBaseUri(baseURI);
}
if ((info != null) && info.HasLineInfo())
{
n.SetLineInfo(info.LineNumber, info.LinePosition);
}
parent.AddNodeSkipNotify(n);
n = null;
}
}
while (r.Read());
}
}
private int ReadChildNodes(XmlReader reader, int parent, int parentNS)
{
int index = 0;
Label_0002:
switch (reader.NodeType)
{
case XmlNodeType.None:
case XmlNodeType.EndElement:
case XmlNodeType.EndEntity:
return index;
case XmlNodeType.Element:
index = this.NewNode();
this.nodes[index].type = XPathNodeType.Element;
this.nodes[index].prefix = reader.Prefix;
this.nodes[index].name = reader.LocalName;
this.nodes[index].ns = reader.NamespaceURI;
this.nodes[index].firstNamespace = parentNS;
this.nodes[index].baseUri = reader.BaseURI;
this.nodes[index].xmlLang = reader.XmlLang;
if (reader.IsEmptyElement)
{
this.ReadAttributes(index, reader);
this.nodes[index].empty = true;
break;
}
this.ReadAttributes(index, reader);
reader.Read();
this.ReadChildNodes(reader, index, this.nodes[index].firstNamespace);
break;
case XmlNodeType.Text:
case XmlNodeType.CDATA:
index = this.LastChild(parent);
if ((index == 0) || (((this.nodes[index].type != XPathNodeType.Text) && (this.nodes[index].type != XPathNodeType.Whitespace)) && (this.nodes[index].type != XPathNodeType.SignificantWhitespace)))
{
index = this.NewNode();
this.nodes[index].baseUri = reader.BaseURI;
this.nodes[index].xmlLang = reader.XmlLang;
this.AddChild(parent, index);
}
this.nodes[index].type = XPathNodeType.Text;
this.nodes[index].val = reader.Value;
goto Label_04EB;
case XmlNodeType.EntityReference:
reader.ResolveEntity();
reader.Read();
this.ReadChildNodes(reader, parent, parentNS);
goto Label_04EB;
case XmlNodeType.ProcessingInstruction:
index = this.NewNode();
this.nodes[index].type = XPathNodeType.ProcessingInstruction;
this.nodes[index].name = reader.LocalName;
this.nodes[index].val = reader.Value;
this.nodes[index].baseUri = reader.BaseURI;
this.nodes[index].xmlLang = reader.XmlLang;
this.AddChild(parent, index);
goto Label_04EB;
case XmlNodeType.Comment:
index = this.NewNode();
this.nodes[index].type = XPathNodeType.Comment;
this.nodes[index].val = reader.Value;
this.nodes[index].baseUri = reader.BaseURI;
this.nodes[index].xmlLang = reader.XmlLang;
this.AddChild(parent, index);
goto Label_04EB;
case XmlNodeType.Whitespace:
goto Label_0331;
case XmlNodeType.SignificantWhitespace:
if (reader.XmlSpace != XmlSpace.Preserve)
{
goto Label_0331;
}
index = this.LastChild(parent);
if ((index == 0) || (((this.nodes[index].type != XPathNodeType.Text) && (this.nodes[index].type != XPathNodeType.Whitespace)) && (this.nodes[index].type != XPathNodeType.SignificantWhitespace)))
{
index = this.NewNode();
this.nodes[index].type = XPathNodeType.SignificantWhitespace;
this.nodes[index].val = reader.Value;
this.nodes[index].baseUri = reader.BaseURI;
this.nodes[index].xmlLang = reader.XmlLang;
this.AddChild(parent, index);
}
else
{
this.nodes[index].val = this.nodes[index].val + reader.Value;
}
goto Label_04EB;
default:
goto Label_04EB;
}
this.AddChild(parent, index);
goto Label_04EB;
Label_0331:
if (this.space == XmlSpace.Preserve)
{
index = this.LastChild(parent);
if ((index != 0) && (((this.nodes[index].type == XPathNodeType.Text) || (this.nodes[index].type == XPathNodeType.Whitespace)) || (this.nodes[index].type == XPathNodeType.SignificantWhitespace)))
{
this.nodes[index].val = this.nodes[index].val + reader.Value;
}
else
{
index = this.NewNode();
this.nodes[index].type = XPathNodeType.Whitespace;
this.nodes[index].val = reader.Value;
this.nodes[index].baseUri = reader.BaseURI;
this.nodes[index].xmlLang = reader.XmlLang;
this.AddChild(parent, index);
}
}
Label_04EB:
if (reader.Read())
{
goto Label_0002;
}
return index;
}
internal void BuildSubtree(XmlReader reader, XmlWriter writer) {
// important (perf) string literal...
string xmlnsUri = XmlReservedNs.NsXmlNs; // http://www.w3.org/2000/xmlns/
ReadState readState = reader.ReadState;
if (readState != ReadState.Initial
&& readState != ReadState.Interactive) {
throw new ArgumentException(Res.GetString(Res.Xml_InvalidOperation), "reader");
}
int level = 0;
if ( readState == ReadState.Initial ) {
if( !reader.Read() )
return;
level++; // if start in initial, read everything (not just first)
}
do {
switch (reader.NodeType) {
case XmlNodeType.Element:
writer.WriteStartElement( reader.Prefix, reader.LocalName, reader.NamespaceURI );
bool isEmptyElement = reader.IsEmptyElement;
while (reader.MoveToNextAttribute()) {
if ((object) reader.NamespaceURI == (object) xmlnsUri) {
if (reader.Prefix.Length == 0) {
// Default namespace declaration "xmlns"
Debug.Assert(reader.LocalName == "xmlns");
writer.WriteAttributeString( "", "xmlns", xmlnsUri, reader.Value );
}
else {
Debug.Assert(reader.Prefix == "xmlns");
writer.WriteAttributeString( "xmlns", reader.LocalName, xmlnsUri, reader.Value );
}
}
else {
writer.WriteStartAttribute(reader.Prefix, reader.LocalName, reader.NamespaceURI);
writer.WriteString(reader.Value);
writer.WriteEndAttribute();
}
}
reader.MoveToElement();
if (isEmptyElement) {
// there might still be a value, if there is a default value specified in the schema
writer.WriteEndElement();
}
else {
level++;
}
break;
case XmlNodeType.EndElement:
writer.WriteFullEndElement();
//should not read beyond the level of the reader's original position.
level--;
break;
case XmlNodeType.Text:
case XmlNodeType.CDATA:
writer.WriteString( reader.Value );
break;
case XmlNodeType.SignificantWhitespace:
case XmlNodeType.Whitespace:
//
writer.WriteString( reader.Value );
break;
case XmlNodeType.Comment:
writer.WriteComment( reader.Value );
break;
case XmlNodeType.ProcessingInstruction:
writer.WriteProcessingInstruction( reader.LocalName , reader.Value);
break;
case XmlNodeType.EntityReference:
reader.ResolveEntity(); //
break;
case XmlNodeType.EndEntity:
case XmlNodeType.None:
case XmlNodeType.DocumentType:
case XmlNodeType.XmlDeclaration:
break;
case XmlNodeType.Attribute:
if ((object) reader.NamespaceURI == (object) xmlnsUri) {
if (reader.Prefix.Length == 0) {
// Default namespace declaration "xmlns"
Debug.Assert(reader.LocalName == "xmlns");
writer.WriteAttributeString( "", "xmlns", xmlnsUri, reader.Value );
}
else {
Debug.Assert(reader.Prefix == "xmlns");
writer.WriteAttributeString( "xmlns", reader.LocalName, xmlnsUri, reader.Value );
}
}
else {
writer.WriteStartAttribute(reader.Prefix, reader.LocalName, reader.NamespaceURI);
writer.WriteString(reader.Value);
writer.WriteEndAttribute();
}
break;
}
}
while( reader.Read() && ( level > 0 ) );
}
public override void ResolveEntity()
{
validatingReader.ResolveEntity();
}
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;
}
/// <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;
}
internal void BuildSubtree(XmlReader reader, XmlWriter writer)
{
string ns = "http://www.w3.org/2000/xmlns/";
ReadState readState = reader.ReadState;
if ((readState != ReadState.Initial) && (readState != ReadState.Interactive))
{
throw new ArgumentException(Res.GetString("Xml_InvalidOperation"), "reader");
}
int num = 0;
if (readState == ReadState.Initial)
{
if (!reader.Read())
{
return;
}
num++;
}
do
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
{
writer.WriteStartElement(reader.Prefix, reader.LocalName, reader.NamespaceURI);
bool isEmptyElement = reader.IsEmptyElement;
while (reader.MoveToNextAttribute())
{
if (reader.NamespaceURI == ns)
{
if (reader.Prefix.Length == 0)
{
writer.WriteAttributeString("", "xmlns", ns, reader.Value);
}
else
{
writer.WriteAttributeString("xmlns", reader.LocalName, ns, reader.Value);
}
}
else
{
writer.WriteStartAttribute(reader.Prefix, reader.LocalName, reader.NamespaceURI);
writer.WriteString(reader.Value);
writer.WriteEndAttribute();
}
}
reader.MoveToElement();
if (isEmptyElement)
{
writer.WriteEndElement();
}
else
{
num++;
}
break;
}
case XmlNodeType.Attribute:
if (reader.NamespaceURI != ns)
{
writer.WriteStartAttribute(reader.Prefix, reader.LocalName, reader.NamespaceURI);
writer.WriteString(reader.Value);
writer.WriteEndAttribute();
break;
}
if (reader.Prefix.Length != 0)
{
writer.WriteAttributeString("xmlns", reader.LocalName, ns, reader.Value);
break;
}
writer.WriteAttributeString("", "xmlns", ns, reader.Value);
break;
case XmlNodeType.Text:
case XmlNodeType.CDATA:
writer.WriteString(reader.Value);
break;
case XmlNodeType.EntityReference:
reader.ResolveEntity();
break;
case XmlNodeType.ProcessingInstruction:
writer.WriteProcessingInstruction(reader.LocalName, reader.Value);
break;
case XmlNodeType.Comment:
writer.WriteComment(reader.Value);
break;
case XmlNodeType.Whitespace:
case XmlNodeType.SignificantWhitespace:
writer.WriteString(reader.Value);
break;
case XmlNodeType.EndElement:
writer.WriteFullEndElement();
num--;
break;
}
}
while (reader.Read() && (num > 0));
}
public bool FindNodeType(XmlReader r, XmlNodeType _nodetype)
{
if (r.NodeType == _nodetype)
return false;
while (r.Read())
{
if (r.NodeType == XmlNodeType.EntityReference)
{
if (r.CanResolveEntity)
r.ResolveEntity();
}
if (r.NodeType == XmlNodeType.ProcessingInstruction && r.NodeType == XmlNodeType.XmlDeclaration)
{
if (String.Compare(r.Name, 0, ST_XML, 0, 3) != 0)
return true;
}
if (r.NodeType == _nodetype)
{
return true;
}
if (r.NodeType == XmlNodeType.Element && (_nodetype == XmlNodeType.Attribute))
{
if (r.MoveToFirstAttribute())
{
return true;
}
}
}
return false;
}
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;
}
internal void ReadContentFrom(XmlReader r)
{
if (r.ReadState != System.Xml.ReadState.Interactive)
{
throw new InvalidOperationException(System.Xml.Linq.Res.GetString("InvalidOperation_ExpectedInteractive"));
}
XContainer parent = this;
NamespaceCache cache = new NamespaceCache();
NamespaceCache cache2 = new NamespaceCache();
do
{
switch (r.NodeType)
{
case XmlNodeType.Element:
{
XElement n = new XElement(cache.Get(r.NamespaceURI).GetName(r.LocalName));
if (r.MoveToFirstAttribute())
{
do
{
n.AppendAttributeSkipNotify(new XAttribute(cache2.Get((r.Prefix.Length == 0) ? string.Empty : r.NamespaceURI).GetName(r.LocalName), r.Value));
}
while (r.MoveToNextAttribute());
r.MoveToElement();
}
parent.AddNodeSkipNotify(n);
if (!r.IsEmptyElement)
{
parent = n;
}
break;
}
case XmlNodeType.Text:
case XmlNodeType.Whitespace:
case XmlNodeType.SignificantWhitespace:
parent.AddStringSkipNotify(r.Value);
break;
case XmlNodeType.CDATA:
parent.AddNodeSkipNotify(new XCData(r.Value));
break;
case XmlNodeType.EntityReference:
if (!r.CanResolveEntity)
{
throw new InvalidOperationException(System.Xml.Linq.Res.GetString("InvalidOperation_UnresolvedEntityReference"));
}
r.ResolveEntity();
break;
case XmlNodeType.ProcessingInstruction:
parent.AddNodeSkipNotify(new XProcessingInstruction(r.Name, r.Value));
break;
case XmlNodeType.Comment:
parent.AddNodeSkipNotify(new XComment(r.Value));
break;
case XmlNodeType.DocumentType:
parent.AddNodeSkipNotify(new XDocumentType(r.LocalName, r.GetAttribute("PUBLIC"), r.GetAttribute("SYSTEM"), r.Value, r.DtdInfo));
break;
case XmlNodeType.EndElement:
if (parent.content == null)
{
parent.content = string.Empty;
}
if (parent == this)
{
return;
}
parent = parent.parent;
break;
case XmlNodeType.EndEntity:
break;
default:
throw new InvalidOperationException(System.Xml.Linq.Res.GetString("InvalidOperation_UnexpectedNodeType", new object[] { r.NodeType }));
}
}
while (r.Read());
}
