/// <summary> /// Copy the navigator subtree to the raw writer. /// </summary> private void CopyNode(XPathNavigator nav) { XPathNodeType nodeType; int iLevel = 0; while (true) { if (CopyShallowNode(nav)) { nodeType = nav.NodeType; if (nodeType == XPathNodeType.Element) { // Copy attributes if (nav.MoveToFirstAttribute()) { do { CopyShallowNode(nav); } while (nav.MoveToNextAttribute()); nav.MoveToParent(); } // Copy namespaces in document order (navigator returns them in reverse document order) XPathNamespaceScope nsScope = (iLevel == 0) ? XPathNamespaceScope.ExcludeXml : XPathNamespaceScope.Local; if (nav.MoveToFirstNamespace(nsScope)) { CopyNamespaces(nav, nsScope); nav.MoveToParent(); } this.xwrt.StartElementContent(); } // If children exist, move down to next level if (nav.MoveToFirstChild()) { iLevel++; continue; } else { // EndElement if (nav.NodeType == XPathNodeType.Element) this.xwrt.WriteEndElement(nav.Prefix, nav.LocalName, nav.NamespaceURI); } } // No children while (true) { if (iLevel == 0) { // The entire subtree has been copied return; } if (nav.MoveToNext()) { // Found a sibling, so break to outer loop break; } // No siblings, so move up to previous level iLevel--; nav.MoveToParent(); // EndElement if (nav.NodeType == XPathNodeType.Element) this.xwrt.WriteFullEndElement(nav.Prefix, nav.LocalName, nav.NamespaceURI); } } }
// Copies the current node from the given XPathNavigator to the writer (including child nodes). public virtual void WriteNode(XPathNavigator navigator, bool defattr) { if (navigator == null) { throw new ArgumentNullException(nameof(navigator)); } int iLevel = 0; navigator = navigator.Clone(); while (true) { bool mayHaveChildren = false; XPathNodeType nodeType = navigator.NodeType; switch (nodeType) { case XPathNodeType.Element: WriteStartElement(navigator.Prefix, navigator.LocalName, navigator.NamespaceURI); // Copy attributes if (navigator.MoveToFirstAttribute()) { do { IXmlSchemaInfo schemaInfo = navigator.SchemaInfo; if (defattr || (schemaInfo == null || !schemaInfo.IsDefault)) { WriteStartAttribute(navigator.Prefix, navigator.LocalName, navigator.NamespaceURI); // copy string value to writer WriteString(navigator.Value); WriteEndAttribute(); } } while (navigator.MoveToNextAttribute()); navigator.MoveToParent(); } // Copy namespaces if (navigator.MoveToFirstNamespace(XPathNamespaceScope.Local)) { WriteLocalNamespaces(navigator); navigator.MoveToParent(); } mayHaveChildren = true; break; case XPathNodeType.Attribute: // do nothing on root level attribute break; case XPathNodeType.Text: WriteString(navigator.Value); break; case XPathNodeType.SignificantWhitespace: case XPathNodeType.Whitespace: WriteWhitespace(navigator.Value); break; case XPathNodeType.Root: mayHaveChildren = true; break; case XPathNodeType.Comment: WriteComment(navigator.Value); break; case XPathNodeType.ProcessingInstruction: WriteProcessingInstruction(navigator.LocalName, navigator.Value); break; case XPathNodeType.Namespace: // do nothing on root level namespace break; default: Debug.Assert(false); break; } if (mayHaveChildren) { // If children exist, move down to next level if (navigator.MoveToFirstChild()) { iLevel++; continue; } else { // EndElement if (navigator.NodeType == XPathNodeType.Element) { if (navigator.IsEmptyElement) { WriteEndElement(); } else { WriteFullEndElement(); } } } } // No children while (true) { if (iLevel == 0) { // The entire subtree has been copied return; } if (navigator.MoveToNext()) { // Found a sibling, so break to outer loop break; } // No siblings, so move up to previous level iLevel--; navigator.MoveToParent(); // EndElement if (navigator.NodeType == XPathNodeType.Element) WriteFullEndElement(); } } }
public override bool MoveToAttribute(string name) { int depth; XPathNavigator nav = GetElemNav(out depth); if (null == nav) { return(false); } string prefix, localname; ValidateNames.SplitQName(name, out prefix, out localname); // watch for a namespace name bool IsXmlnsNoPrefix = false; if ((IsXmlnsNoPrefix = (0 == prefix.Length && localname == "xmlns")) || (prefix == "xmlns")) { if (IsXmlnsNoPrefix) { localname = string.Empty; } if (nav.MoveToFirstNamespace(XPathNamespaceScope.Local)) { do { if (nav.LocalName == localname) { goto FoundMatch; } } while (nav.MoveToNextNamespace(XPathNamespaceScope.Local)); } } else if (0 == prefix.Length) { // the empty prefix always means empty namespaceUri for attributes if (nav.MoveToAttribute(localname, string.Empty)) { goto FoundMatch; } } else { if (nav.MoveToFirstAttribute()) { do { if (nav.LocalName == localname && nav.Prefix == prefix) { goto FoundMatch; } } while (nav.MoveToNextAttribute()); } } return(false); FoundMatch: if (state == State.InReadBinary) { readBinaryHelper.Finish(); state = savedState; } MoveToAttr(nav, depth + 1); return(true); }
/// <summary> /// Copy all namespaces of the specified type (in-scope, exclude-xml, local) in document order to output. /// </summary> private void CopyNamespaces(XPathNavigator navigator, XPathNamespaceScope nsScope) { Debug.Assert(navigator.NodeType == XPathNodeType.Element, "Only elements have namespaces to copy"); // Default namespace undeclaration isn't included in navigator's namespace list, so add it now if (navigator.NamespaceURI.Length == 0) { Debug.Assert(navigator.LocalName.Length != 0, "xmlns:foo='' isn't allowed"); WriteNamespaceDeclarationUnchecked(string.Empty, string.Empty); } // Since the namespace list is arranged in reverse-document order, recursively reverse it. if (navigator.MoveToFirstNamespace(nsScope)) { CopyNamespacesHelper(navigator, nsScope); navigator.MoveToParent(); } }
/// <summary> /// Initialize the NamespaceIterator. /// </summary> public void Create(XPathNavigator context) { // Push all of context's in-scope namespaces onto a stack in order to return them in document order // (MoveToXXXNamespace methods return namespaces in reverse document order) this.navStack.Reset(); if (context.MoveToFirstNamespace(XPathNamespaceScope.All)) { do { // Don't return the default namespace undeclaration if (context.LocalName.Length != 0 || context.Value.Length != 0) this.navStack.Push(context.Clone()); } while (context.MoveToNextNamespace(XPathNamespaceScope.All)); context.MoveToParent(); } }
public override bool MoveToNextAttribute() { switch (this.state) { case State.Content: return(MoveToFirstAttribute()); case State.Attribute: { if (XPathNodeType.Attribute == this.nav.NodeType) { return(this.nav.MoveToNextAttribute()); } // otherwise it is on a namespace... namespace are in reverse order Debug.Assert(XPathNodeType.Namespace == this.nav.NodeType); XPathNavigator nav = this.nav.Clone(); if (!nav.MoveToParent()) { return(false); // shouldn't happen } if (!nav.MoveToFirstNamespace(XPathNamespaceScope.Local)) { return(false); // shouldn't happen } if (nav.IsSamePosition(this.nav)) { // this was the last one... start walking attributes nav.MoveToParent(); if (!nav.MoveToFirstAttribute()) { return(false); } // otherwise we are there this.nav.MoveTo(nav); return(true); } else { XPathNavigator prev = nav.Clone(); for (;;) { if (!nav.MoveToNextNamespace(XPathNamespaceScope.Local)) { Debug.Assert(false, "Couldn't find Namespace Node! Should not happen!"); return(false); } if (nav.IsSamePosition(this.nav)) { this.nav.MoveTo(prev); return(true); } prev.MoveTo(nav); } // found previous namespace position } } case State.AttrVal: depth--; this.state = State.Attribute; if (!MoveToNextAttribute()) { depth++; this.state = State.AttrVal; return(false); } this.nodeType = XmlNodeType.Attribute; return(true); case State.InReadBinary: state = savedState; if (!MoveToNextAttribute()) { state = State.InReadBinary; return(false); } readBinaryHelper.Finish(); return(true); default: return(false); } }
public static void WriteNode(this XmlWriter writer, XPathNavigator navigator, bool defattr) { if (navigator == null) { throw new ArgumentNullException("navigator"); } int iLevel = 0; navigator = navigator.Clone(); while (true) { bool mayHaveChildren = false; XPathNodeType nodeType = navigator.NodeType; switch (nodeType) { case XPathNodeType.Element: writer.WriteStartElement(navigator.Prefix, navigator.LocalName, navigator.NamespaceURI); // Copy attributes if (navigator.MoveToFirstAttribute()) { do { writer.WriteStartAttribute(navigator.Prefix, navigator.LocalName, navigator.NamespaceURI); // copy string value to writer writer.WriteString(navigator.Value); writer.WriteEndAttribute(); } while (navigator.MoveToNextAttribute()); navigator.MoveToParent(); } // Copy namespaces if (navigator.MoveToFirstNamespace(XPathNamespaceScope.Local)) { writer.WriteLocalNamespaces(navigator); navigator.MoveToParent(); } mayHaveChildren = true; break; case XPathNodeType.Attribute: // do nothing on root level attribute break; case XPathNodeType.Text: writer.WriteString(navigator.Value); break; case XPathNodeType.SignificantWhitespace: case XPathNodeType.Whitespace: writer.WriteWhitespace(navigator.Value); break; case XPathNodeType.Root: mayHaveChildren = true; break; case XPathNodeType.Comment: writer.WriteComment(navigator.Value); break; case XPathNodeType.ProcessingInstruction: writer.WriteProcessingInstruction(navigator.LocalName, navigator.Value); break; case XPathNodeType.Namespace: // do nothing on root level namespace break; default: Debug.Assert(false); break; } if (mayHaveChildren) { // If children exist, move down to next level if (navigator.MoveToFirstChild()) { iLevel++; continue; } else { // EndElement if (navigator.NodeType == XPathNodeType.Element) { if (navigator.IsEmptyElement) { writer.WriteEndElement(); } else { writer.WriteFullEndElement(); } } } } // No children while (true) { if (iLevel == 0) { // The entire subtree has been copied return; } if (navigator.MoveToNext()) { // Found a sibling, so break to outer loop break; } // No siblings, so move up to previous level iLevel--; navigator.MoveToParent(); // EndElement if (navigator.NodeType == XPathNodeType.Element) { writer.WriteFullEndElement(); } } } }
public override bool MoveToAttribute(string name) { int num; string str; string str2; XPathNavigator elemNav = this.GetElemNav(out num); if (elemNav == null) { return(false); } ValidateNames.SplitQName(name, out str, out str2); bool flag = false; if ((flag = (str.Length == 0) && (str2 == "xmlns")) || (str == "xmlns")) { if (flag) { str2 = string.Empty; } if (elemNav.MoveToFirstNamespace(XPathNamespaceScope.Local)) { do { if (elemNav.LocalName == str2) { goto Label_00B5; } }while (elemNav.MoveToNextNamespace(XPathNamespaceScope.Local)); } } else { if (str.Length == 0) { if (!elemNav.MoveToAttribute(str2, string.Empty)) { goto Label_00B3; } goto Label_00B5; } if (elemNav.MoveToFirstAttribute()) { do { if ((elemNav.LocalName == str2) && (elemNav.Prefix == str)) { goto Label_00B5; } }while (elemNav.MoveToNextAttribute()); } } Label_00B3: return(false); Label_00B5: if (this.state == State.InReadBinary) { this.readBinaryHelper.Finish(); this.state = this.savedState; } this.MoveToAttr(elemNav, num + 1); return(true); }
public CompiledStylesheet Compile (XPathNavigator nav, XmlResolver res, Evidence evidence) { this.xpathParser = new XPathParser (this); this.patternParser = new XsltPatternParser (this); this.res = res; if (res == null) this.res = new XmlUrlResolver (); this.evidence = evidence; // reject empty document. if (nav.NodeType == XPathNodeType.Root && !nav.MoveToFirstChild ()) throw new XsltCompileException ("Stylesheet root element must be either \"stylesheet\" or \"transform\" or any literal element", null, nav); while (nav.NodeType != XPathNodeType.Element) nav.MoveToNext(); stylesheetVersion = nav.GetAttribute ("version", (nav.NamespaceURI != XsltNamespace) ? XsltNamespace : String.Empty); outputs [""] = new XslOutput ("", stylesheetVersion); PushInputDocument (nav); if (nav.MoveToFirstNamespace (XPathNamespaceScope.ExcludeXml)) { do { nsMgr.AddNamespace (nav.LocalName, nav.Value); } while (nav.MoveToNextNamespace (XPathNamespaceScope.ExcludeXml)); nav.MoveToParent (); } try { rootStyle = new XslStylesheet (); rootStyle.Compile (this); } catch (XsltCompileException) { throw; } catch (Exception x) { throw new XsltCompileException ("XSLT compile error. " + x.Message, x, Input); } return new CompiledStylesheet (rootStyle, globalVariables, attrSets, nsMgr, keys, outputs, decimalFormats, msScripts); }
public void ReadSubtreeNamespace () { string xml = "<root xmlns='urn:foo' />"; nav = GetXmlDocumentNavigator (xml); nav.MoveToFirstChild (); nav.MoveToFirstNamespace (); nav.ReadSubtree (); }
void CopyNode (XslTransformProcessor p, XPathNavigator nav) { Outputter outputter = p.Out; switch (nav.NodeType) { case XPathNodeType.Root: XPathNodeIterator itr = nav.SelectChildren (XPathNodeType.All); while (itr.MoveNext ()) CopyNode (p, itr.Current); break; case XPathNodeType.Element: bool isCData = p.InsideCDataElement; string prefix = nav.Prefix; string ns = nav.NamespaceURI; p.PushElementState (prefix, nav.LocalName, ns, false); outputter.WriteStartElement (prefix, nav.LocalName, ns); if (nav.MoveToFirstNamespace (XPathNamespaceScope.ExcludeXml)) { do { if (prefix == nav.Name) continue; if (nav.Name.Length == 0 && ns.Length == 0) continue; outputter.WriteNamespaceDecl (nav.Name, nav.Value); } while (nav.MoveToNextNamespace (XPathNamespaceScope.ExcludeXml)); nav.MoveToParent (); } if (nav.MoveToFirstAttribute()) { do { outputter.WriteAttributeString (nav.Prefix, nav.LocalName, nav.NamespaceURI, nav.Value); } while (nav.MoveToNextAttribute ()); nav.MoveToParent(); } if (nav.MoveToFirstChild ()) { do { CopyNode (p, nav); } while (nav.MoveToNext ()); nav.MoveToParent (); } if (nav.IsEmptyElement) outputter.WriteEndElement (); else outputter.WriteFullEndElement (); p.PopCDataState (isCData); break; case XPathNodeType.Namespace: if (nav.Name != p.XPathContext.ElementPrefix && (p.XPathContext.ElementNamespace.Length > 0 || nav.Name.Length > 0)) outputter.WriteNamespaceDecl (nav.Name, nav.Value); break; case XPathNodeType.Attribute: outputter.WriteAttributeString (nav.Prefix, nav.LocalName, nav.NamespaceURI, nav.Value); break; case XPathNodeType.Whitespace: case XPathNodeType.SignificantWhitespace: bool cdata = outputter.InsideCDataSection; outputter.InsideCDataSection = false; outputter.WriteString (nav.Value); outputter.InsideCDataSection = cdata; break; case XPathNodeType.Text: outputter.WriteString (nav.Value); break; case XPathNodeType.ProcessingInstruction: outputter.WriteProcessingInstruction (nav.Name, nav.Value); break; case XPathNodeType.Comment: outputter.WriteComment (nav.Value); break; } }
public virtual void WriteNode(XPathNavigator navigator, bool defattr) { bool flag; if (navigator == null) { throw new ArgumentNullException("navigator"); } int num = 0; navigator = navigator.Clone(); Label_0018: flag = false; switch (navigator.NodeType) { case XPathNodeType.Root: flag = true; break; case XPathNodeType.Element: this.WriteStartElement(navigator.Prefix, navigator.LocalName, navigator.NamespaceURI); if (navigator.MoveToFirstAttribute()) { do { IXmlSchemaInfo schemaInfo = navigator.SchemaInfo; if ((defattr || (schemaInfo == null)) || !schemaInfo.IsDefault) { this.WriteStartAttribute(navigator.Prefix, navigator.LocalName, navigator.NamespaceURI); this.WriteString(navigator.Value); this.WriteEndAttribute(); } } while (navigator.MoveToNextAttribute()); navigator.MoveToParent(); } if (navigator.MoveToFirstNamespace(XPathNamespaceScope.Local)) { this.WriteLocalNamespaces(navigator); navigator.MoveToParent(); } flag = true; break; case XPathNodeType.Text: this.WriteString(navigator.Value); break; case XPathNodeType.SignificantWhitespace: case XPathNodeType.Whitespace: this.WriteWhitespace(navigator.Value); break; case XPathNodeType.ProcessingInstruction: this.WriteProcessingInstruction(navigator.LocalName, navigator.Value); break; case XPathNodeType.Comment: this.WriteComment(navigator.Value); break; } if (flag) { if (navigator.MoveToFirstChild()) { num++; goto Label_0018; } if (navigator.NodeType == XPathNodeType.Element) { if (navigator.IsEmptyElement) { this.WriteEndElement(); } else { this.WriteFullEndElement(); } } } while (num != 0) { if (navigator.MoveToNext()) { goto Label_0018; } num--; navigator.MoveToParent(); if (navigator.NodeType == XPathNodeType.Element) { this.WriteFullEndElement(); } } }
public override bool MoveToNextAttribute() { switch (this.state) { case State.Content: return(this.MoveToFirstAttribute()); case State.Attribute: if (XPathNodeType.Attribute != this.nav.NodeType) { XPathNavigator other = this.nav.Clone(); if (other.MoveToParent()) { if (!other.MoveToFirstNamespace(XPathNamespaceScope.Local)) { return(false); } if (other.IsSamePosition(this.nav)) { other.MoveToParent(); if (!other.MoveToFirstAttribute()) { return(false); } this.nav.MoveTo(other); return(true); } XPathNavigator navigator2 = other.Clone(); while (other.MoveToNextNamespace(XPathNamespaceScope.Local)) { if (other.IsSamePosition(this.nav)) { this.nav.MoveTo(navigator2); return(true); } navigator2.MoveTo(other); } } return(false); } return(this.nav.MoveToNextAttribute()); case State.AttrVal: this.depth--; this.state = State.Attribute; if (this.MoveToNextAttribute()) { break; } this.depth++; this.state = State.AttrVal; return(false); case State.InReadBinary: this.state = this.savedState; if (this.MoveToNextAttribute()) { this.readBinaryHelper.Finish(); return(true); } this.state = State.InReadBinary; return(false); default: return(false); } this.nodeType = XmlNodeType.Attribute; return(true); }
private void XmlNamespaceNode (XPathNavigator nav) { string xhtml = "http://www.w3.org/1999/xhtml"; string xmlNS = "http://www.w3.org/XML/1998/namespace"; nav.MoveToFirstChild (); AssertNavigator ("#1", nav, XPathNodeType.Element, "", "html", xhtml, "html", "test.", false, true, false); Assert.IsTrue (nav.MoveToFirstNamespace (XPathNamespaceScope.Local)); AssertNavigator ("#2", nav, XPathNodeType.Namespace, "", "", "", "", xhtml, false, false, false); // Test difference between Local, ExcludeXml and All. Assert.IsTrue (!nav.MoveToNextNamespace (XPathNamespaceScope.Local)); Assert.IsTrue (!nav.MoveToNextNamespace (XPathNamespaceScope.ExcludeXml)); // LAMESPEC: MS.NET 1.0 XmlDocument seems to have some bugs around here. // see http://support.microsoft.com/default.aspx?scid=kb;EN-US;Q316808 #if true Assert.IsTrue (nav.MoveToNextNamespace (XPathNamespaceScope.All)); AssertNavigator ("#3", nav, XPathNodeType.Namespace, "", "xml", "", "xml", xmlNS, false, false, false); Assert.IsTrue (!nav.MoveToNextNamespace (XPathNamespaceScope.All)); #endif // Test to check if MoveToRoot() resets Namespace node status. nav.MoveToRoot (); AssertNavigator ("#4", nav, XPathNodeType.Root, "", "", "", "", "test.", false, true, false); nav.MoveToFirstChild (); // Test without XPathNamespaceScope argument. Assert.IsTrue (nav.MoveToFirstNamespace ()); Assert.IsTrue (nav.MoveToNextNamespace ()); AssertNavigator ("#5", nav, XPathNodeType.Namespace, "", "xml", "", "xml", xmlNS, false, false, false); // Test MoveToParent() Assert.IsTrue (nav.MoveToParent ()); AssertNavigator ("#6", nav, XPathNodeType.Element, "", "html", xhtml, "html", "test.", false, true, false); nav.MoveToFirstChild (); // body // Test difference between Local and ExcludeXml Assert.IsTrue (!nav.MoveToFirstNamespace (XPathNamespaceScope.Local), "Local should fail"); Assert.IsTrue (nav.MoveToFirstNamespace (XPathNamespaceScope.ExcludeXml), "ExcludeXml should succeed"); AssertNavigator ("#7", nav, XPathNodeType.Namespace, "", "", "", "", xhtml, false, false, false); Assert.IsTrue (nav.MoveToNextNamespace (XPathNamespaceScope.All)); AssertNavigator ("#8", nav, XPathNodeType.Namespace, "", "xml", "", "xml", xmlNS, false, false, false); Assert.IsTrue (nav.MoveToParent ()); AssertNavigator ("#9", nav, XPathNodeType.Element, "", "body", xhtml, "body", "test.", false, true, false); nav.MoveToRoot (); AssertNavigator ("#10", nav, XPathNodeType.Root, "", "", "", "", "test.", false, true, false); }
public virtual void WriteNode (XPathNavigator navigator, bool defattr) { if (navigator == null) throw new ArgumentNullException ("navigator"); switch (navigator.NodeType) { case XPathNodeType.Attribute: // no operation break; case XPathNodeType.Namespace: // no operation break; case XPathNodeType.Text: WriteString (navigator.Value); break; case XPathNodeType.SignificantWhitespace: WriteWhitespace (navigator.Value); break; case XPathNodeType.Whitespace: WriteWhitespace (navigator.Value); break; case XPathNodeType.Comment: WriteComment (navigator.Value); break; case XPathNodeType.ProcessingInstruction: WriteProcessingInstruction (navigator.Name, navigator.Value); break; case XPathNodeType.Root: if (navigator.MoveToFirstChild ()) { do { WriteNode (navigator, defattr); } while (navigator.MoveToNext ()); navigator.MoveToParent (); } break; case XPathNodeType.Element: WriteStartElement (navigator.Prefix, navigator.LocalName, navigator.NamespaceURI); if (navigator.MoveToFirstNamespace (XPathNamespaceScope.Local)) { do { if (defattr || navigator.SchemaInfo == null || navigator.SchemaInfo.IsDefault) WriteAttributeString (navigator.Prefix, navigator.LocalName == String.Empty ? "xmlns" : navigator.LocalName, "http://www.w3.org/2000/xmlns/", navigator.Value); } while (navigator.MoveToNextNamespace (XPathNamespaceScope.Local)); navigator.MoveToParent (); } if (navigator.MoveToFirstAttribute ()) { do { if (defattr || navigator.SchemaInfo == null || navigator.SchemaInfo.IsDefault) WriteAttributeString (navigator.Prefix, navigator.LocalName, navigator.NamespaceURI, navigator.Value); } while (navigator.MoveToNextAttribute ()); navigator.MoveToParent (); } if (navigator.MoveToFirstChild ()) { do { WriteNode (navigator, defattr); } while (navigator.MoveToNext ()); navigator.MoveToParent (); } if (navigator.IsEmptyElement) WriteEndElement (); else WriteFullEndElement (); break; default: throw new NotSupportedException (); } }
private void MoveToNamespaces (XPathNavigator nav) { XPathNodeIterator iter = nav.Select ("//e"); iter.MoveNext (); nav.MoveTo (iter.Current); Assert.AreEqual ("e", nav.Name, "#1"); nav.MoveToFirstNamespace (); Assert.AreEqual ("x", nav.Name, "#2"); nav.MoveToNextNamespace (); Assert.AreEqual ("xml", nav.Name, "#3"); }
private void ProcessElementNode(XPathNavigator node, InternalFormContext ctx) { Debug.Assert(node.NodeType == XPathNodeType.Element); log.Debug("Processing element node: {0} ({1})", node.Name, node.NamespaceURI); if (IsPreprocessElement(node)) { PreprocessElementNode(node, ctx); } else { ctx.Output.WriteStartElement(node.Prefix, node.LocalName, node.NamespaceURI); if (node.MoveToFirstAttribute()) { do { ctx.Output.WriteAttributeString(node.Prefix, node.LocalName, node.NamespaceURI, node.Value); } while (node.MoveToNextAttribute()); node.MoveToParent(); } if (!ctx.FirstElementHandled) { if (node.MoveToFirstNamespace()) { do { log.Debug("Writing namespace declaration: {0}:{1}", node.LocalName, node.Value); ctx.Output.WriteAttributeString("xmlns", node.LocalName, null, node.Value); } while (node.MoveToNextNamespace()); node.MoveToParent(); } ctx.FirstElementHandled = true; } if (!node.IsEmptyElement) { VisitChildren(node, ctx); } ctx.Output.WriteEndElement(); log.Debug("End processing element node: {0} ({1})", node.Name, node.NamespaceURI); } }