/// <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(); }