public override bool MoveToFirstAttribute() { int num; XPathNavigator elemNav = this.GetElemNav(out num); if (elemNav != null) { if (elemNav.MoveToFirstNamespace(XPathNamespaceScope.Local)) { while (elemNav.MoveToNextNamespace(XPathNamespaceScope.Local)) { } goto Label_002A; } if (elemNav.MoveToFirstAttribute()) { goto Label_002A; } } return(false); Label_002A: if (this.state == State.InReadBinary) { this.readBinaryHelper.Finish(); this.state = this.savedState; } this.MoveToAttr(elemNav, num + 1); return(true); }
public virtual IDictionary <string, string> GetNamespacesInScope(XmlNamespaceScope scope) { IDictionary <string, string> table = new Dictionary <string, string> (); XPathNamespaceScope xpscope = scope == XmlNamespaceScope.Local ? XPathNamespaceScope.Local : scope == XmlNamespaceScope.ExcludeXml ? XPathNamespaceScope.ExcludeXml : XPathNamespaceScope.All; XPathNavigator nav = Clone(); if (nav.NodeType != XPathNodeType.Element) { nav.MoveToParent(); } if (!nav.MoveToFirstNamespace(xpscope)) { return(table); } do { table.Add(nav.Name, nav.Value); } while (nav.MoveToNextNamespace(xpscope)); return(table); }
public override bool MoveToFirstAttribute() { int depth; XPathNavigator nav = GetElemNav(out depth); if (null != nav) { if (nav.MoveToFirstNamespace(XPathNamespaceScope.Local)) { // attributes are in reverse order while (nav.MoveToNextNamespace(XPathNamespaceScope.Local)) { ; } goto FoundMatch; } if (nav.MoveToFirstAttribute()) { goto FoundMatch; } } return(false); FoundMatch: if (_state == State.InReadBinary) { _readBinaryHelper.Finish(); _state = _savedState; } MoveToAttr(nav, depth + 1); return(true); }
private XmlNodeOrder CompareSiblings(XPathNavigator n1, XPathNavigator n2) { bool attr1 = n1.NodeType == XPathNodeType.Attribute; bool attr2 = n2.NodeType == XPathNodeType.Attribute; bool ns1 = n1.NodeType == XPathNodeType.Namespace; bool ns2 = n2.NodeType == XPathNodeType.Namespace; if (!ns1 && !ns2 && !attr1 && !attr2) { while (n1.MoveToNext()) { if (n1.IsSamePosition(n2)) { return(XmlNodeOrder.Before); } } return(XmlNodeOrder.After); } if (attr1 && attr2) { while (n1.MoveToNextAttribute()) { if (n1.IsSamePosition(n2)) { return(XmlNodeOrder.Before); } } return(XmlNodeOrder.After); } if (attr1) { return(XmlNodeOrder.After); } if (attr2) { return(XmlNodeOrder.Before); } if (ns1 && ns2) { while (n1.MoveToNextNamespace()) { if (n1.IsSamePosition(n2)) { return(XmlNodeOrder.Before); } } return(XmlNodeOrder.After); } if (ns1) { return(XmlNodeOrder.After); } Debug.Assert(ns2); return(XmlNodeOrder.Before); }
public override bool MoveToAttribute(string localName, string namespaceName) { if (localName == null) { throw new ArgumentNullException("localName"); } int depth = this.depth; XPathNavigator elemNav = this.GetElemNav(out depth); if (elemNav != null) { if (namespaceName == "http://www.w3.org/2000/xmlns/") { if (localName == "xmlns") { localName = string.Empty; } if (elemNav.MoveToFirstNamespace(XPathNamespaceScope.Local)) { do { if (elemNav.LocalName == localName) { goto Label_007A; } }while (elemNav.MoveToNextNamespace(XPathNamespaceScope.Local)); } } else { if (namespaceName == null) { namespaceName = string.Empty; } if (elemNav.MoveToAttribute(localName, namespaceName)) { goto Label_007A; } } } return(false); Label_007A: if (this.state == State.InReadBinary) { this.readBinaryHelper.Finish(); this.state = this.savedState; } this.MoveToAttr(elemNav, depth + 1); return(true); }
public override bool MoveToAttribute(string localName, string namespaceName) { if (null == localName) { throw new ArgumentNullException("localName"); } int depth = _depth; XPathNavigator nav = GetElemNav(out depth); if (null != nav) { if (namespaceName == XmlConst.ReservedNsXmlNs) { if (localName == "xmlns") { localName = string.Empty; } if (nav.MoveToFirstNamespace(XPathNamespaceScope.Local)) { do { if (nav.LocalName == localName) { goto FoundMatch; } } while (nav.MoveToNextNamespace(XPathNamespaceScope.Local)); } } else { if (null == namespaceName) { namespaceName = string.Empty; } if (nav.MoveToAttribute(localName, namespaceName)) { goto FoundMatch; } } } return(false); FoundMatch: if (_state == State.InReadBinary) { _readBinaryHelper.Finish(); _state = _savedState; } MoveToAttr(nav, depth + 1); return(true); }
private static void WriteLocalNamespaces(this XmlWriter writer, XPathNavigator nsNav) { string prefix = nsNav.LocalName; string ns = nsNav.Value; if (nsNav.MoveToNextNamespace(XPathNamespaceScope.Local)) { writer.WriteLocalNamespaces(nsNav); } if (prefix.Length == 0) { writer.WriteAttributeString(string.Empty, "xmlns", XmlConst.ReservedNsXmlNs, ns); } else { writer.WriteAttributeString("xmlns", prefix, XmlConst.ReservedNsXmlNs, ns); } }
private static string GetNamespaceByIndex(XPathNavigator nav, int index, out int count) { string str = nav.Value; string str2 = null; if (nav.MoveToNextNamespace(XPathNamespaceScope.Local)) { str2 = GetNamespaceByIndex(nav, index, out count); } else { count = 0; } if (count == index) { str2 = str; } count++; return(str2); }
virtual string LookupPrefix(string namespaceUri) { XPathNavigator nav = Clone(); if (nav.NodeType != XPathNodeType.Element) { nav.MoveToParent(); } if (!nav.MoveToFirstNamespace()) { return(null); } do { if (nav.Value == namespaceUri) { return(nav.Name); } } while (nav.MoveToNextNamespace()); return(null); }
private static string GetNamespaceByIndex(XPathNavigator nav, int index, out int count) { string thisValue = nav.Value; string value = null; if (nav.MoveToNextNamespace(XPathNamespaceScope.Local)) { value = GetNamespaceByIndex(nav, index, out count); } else { count = 0; } if (count == index) { Debug.Assert(value == null); value = thisValue; } count++; return(value); }
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 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); }
private XmlNodeOrder CompareSiblings(XPathNavigator n1, XPathNavigator n2) { int num = 0; switch (n1.NodeType) { case XPathNodeType.Attribute: num++; break; case XPathNodeType.Namespace: break; default: num += 2; break; } switch (n2.NodeType) { case XPathNodeType.Attribute: num--; if (num == 0) { while (n1.MoveToNextAttribute()) { if (n1.IsSamePosition(n2)) { return XmlNodeOrder.Before; } } } break; case XPathNodeType.Namespace: if (num == 0) { while (n1.MoveToNextNamespace()) { if (n1.IsSamePosition(n2)) { return XmlNodeOrder.Before; } } } break; default: num -= 2; if (num == 0) { while (n1.MoveToNext()) { if (n1.IsSamePosition(n2)) { return XmlNodeOrder.Before; } } } break; } if (num >= 0) { return XmlNodeOrder.After; } return XmlNodeOrder.Before; }
// Copy local namespaces on the navigator's current node to the raw writer. The namespaces are returned by the navigator in reversed order. // The recursive call reverses them back. private void WriteLocalNamespaces(XPathNavigator nsNav) { string prefix = nsNav.LocalName; string ns = nsNav.Value; if (nsNav.MoveToNextNamespace(XPathNamespaceScope.Local)) { WriteLocalNamespaces(nsNav); } if (prefix.Length == 0) { WriteAttributeString(string.Empty, "xmlns", XmlReservedNs.NsXmlNs, ns); } else { WriteAttributeString("xmlns", prefix, XmlReservedNs.NsXmlNs, ns); } }
private void WriteLocalNamespaces(XPathNavigator nsNav) { string localName = nsNav.LocalName; string str2 = nsNav.Value; if (nsNav.MoveToNextNamespace(XPathNamespaceScope.Local)) { this.WriteLocalNamespaces(nsNav); } if (localName.Length == 0) { this.WriteAttributeString(string.Empty, "xmlns", "http://www.w3.org/2000/xmlns/", str2); } else { this.WriteAttributeString("xmlns", localName, "http://www.w3.org/2000/xmlns/", str2); } }
private static string GetNamespaceByIndex(XPathNavigator nav, int index, out int count) { string thisValue = nav.Value; string value = null; if (nav.MoveToNextNamespace(XPathNamespaceScope.Local)) { value = GetNamespaceByIndex(nav, index, out count); } else { count = 0; } if (count == index) { Debug.Assert(value == null); value = thisValue; } count++; return value; }
public override bool MoveToNextAttribute() { switch (_state) { case State.Content: return(MoveToFirstAttribute()); case State.Attribute: { if (XPathNodeType.Attribute == _nav.NodeType) { return(_nav.MoveToNextAttribute()); } // otherwise it is on a namespace... namespace are in reverse order Debug.Assert(XPathNodeType.Namespace == _nav.NodeType); XPathNavigator nav = _nav.Clone(); if (!nav.MoveToParent()) { return(false); // shouldn't happen } if (!nav.MoveToFirstNamespace(XPathNamespaceScope.Local)) { return(false); // shouldn't happen } if (nav.IsSamePosition(_nav)) { // this was the last one... start walking attributes nav.MoveToParent(); if (!nav.MoveToFirstAttribute()) { return(false); } // otherwise we are there _nav.MoveTo(nav); return(true); } else { XPathNavigator prev = nav.Clone(); for (; ;) { if (!nav.MoveToNextNamespace(XPathNamespaceScope.Local)) { Debug.Fail("Couldn't find Namespace Node! Should not happen!"); return(false); } if (nav.IsSamePosition(_nav)) { _nav.MoveTo(prev); return(true); } prev.MoveTo(nav); } // found previous namespace position } } case State.AttrVal: _depth--; _state = State.Attribute; if (!MoveToNextAttribute()) { _depth++; _state = State.AttrVal; return(false); } _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 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 (); } }
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); }
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 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); }
public virtual XmlNodeOrder ComparePosition(XPathNavigator nav) { if (IsSamePosition(nav)) { return(XmlNodeOrder.Same); } // quick check for direct descendant if (IsDescendant(nav)) { return(XmlNodeOrder.Before); } // quick check for direct ancestor if (nav.IsDescendant(this)) { return(XmlNodeOrder.After); } XPathNavigator nav1 = Clone(); XPathNavigator nav2 = nav.Clone(); // check if document instance is the same. nav1.MoveToRoot(); nav2.MoveToRoot(); if (!nav1.IsSamePosition(nav2)) { return(XmlNodeOrder.Unknown); } nav1.MoveTo(this); nav2.MoveTo(nav); int depth1 = 0; while (nav1.MoveToParent()) { depth1++; } nav1.MoveTo(this); int depth2 = 0; while (nav2.MoveToParent()) { depth2++; } nav2.MoveTo(nav); // find common parent depth int common = depth1; for (; common > depth2; common--) { nav1.MoveToParent(); } for (int i = depth2; i > common; i--) { nav2.MoveToParent(); } while (!nav1.IsSamePosition(nav2)) { nav1.MoveToParent(); nav2.MoveToParent(); common--; } // For each this and target, move to the node that is // ancestor of the node and child of the common parent. nav1.MoveTo(this); for (int i = depth1; i > common + 1; i--) { nav1.MoveToParent(); } nav2.MoveTo(nav); for (int i = depth2; i > common + 1; i--) { nav2.MoveToParent(); } // Those children of common parent are comparable. // namespace nodes precede to attributes, and they // precede to other nodes. if (nav1.NodeType == XPathNodeType.Namespace) { if (nav2.NodeType != XPathNodeType.Namespace) { return(XmlNodeOrder.Before); } while (nav1.MoveToNextNamespace()) { if (nav1.IsSamePosition(nav2)) { return(XmlNodeOrder.Before); } } return(XmlNodeOrder.After); } if (nav2.NodeType == XPathNodeType.Namespace) { return(XmlNodeOrder.After); } if (nav1.NodeType == XPathNodeType.Attribute) { if (nav2.NodeType != XPathNodeType.Attribute) { return(XmlNodeOrder.Before); } while (nav1.MoveToNextAttribute()) { if (nav1.IsSamePosition(nav2)) { return(XmlNodeOrder.Before); } } return(XmlNodeOrder.After); } while (nav1.MoveToNext()) { if (nav1.IsSamePosition(nav2)) { return(XmlNodeOrder.Before); } } return(XmlNodeOrder.After); }
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); }
private static string GetNamespaceByIndex(XPathNavigator nav, int index, out int count) { string str = nav.Value; string str2 = null; if (nav.MoveToNextNamespace(XPathNamespaceScope.Local)) { str2 = GetNamespaceByIndex(nav, index, out count); } else { count = 0; } if (count == index) { str2 = str; } count++; return str2; }
/// <summary> /// Copy all or some (which depends on nsScope) of the namespaces on the navigator's current node to the /// raw writer. /// </summary> private void CopyNamespaces(XPathNavigator nav, XPathNamespaceScope nsScope) { string prefix = nav.LocalName; string ns = nav.Value; if (nav.MoveToNextNamespace(nsScope)) { CopyNamespaces(nav, nsScope); } this.xwrt.WriteNamespaceDeclaration(prefix, ns); }
// Copy local namespaces on the navigator's current node to the raw writer. The namespaces are returned by the navigator in reversed order. // The recursive call reverses them back. private async Task WriteLocalNamespacesAsync(XPathNavigator nsNav) { string prefix = nsNav.LocalName; string ns = nsNav.Value; if (nsNav.MoveToNextNamespace(XPathNamespaceScope.Local)) { await WriteLocalNamespacesAsync(nsNav).ConfigureAwait(false); } if (prefix.Length == 0) { await WriteAttributeStringAsync(string.Empty, "xmlns", XmlReservedNs.NsXmlNs, ns).ConfigureAwait(false); } else { await WriteAttributeStringAsync("xmlns", prefix, XmlReservedNs.NsXmlNs, ns).ConfigureAwait(false); } }
/// <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(); } }
private XmlNodeOrder CompareSiblings(XPathNavigator n1, XPathNavigator n2){ bool attr1 = n1.NodeType == XPathNodeType.Attribute; bool attr2 = n2.NodeType == XPathNodeType.Attribute; bool ns1 = n1.NodeType == XPathNodeType.Namespace; bool ns2 = n2.NodeType == XPathNodeType.Namespace; if (! ns1 && ! ns2 && ! attr1 && ! attr2) { while (n1.MoveToNext()) { if (n1.IsSamePosition(n2)) return XmlNodeOrder.Before; } return XmlNodeOrder.After; } if (attr1 && attr2) { while (n1.MoveToNextAttribute()){ if (n1.IsSamePosition(n2)) return XmlNodeOrder.Before; } return XmlNodeOrder.After; } if (attr1){ return XmlNodeOrder.After; } if (attr2){ return XmlNodeOrder.Before; } if (ns1 && ns2) { while (n1.MoveToNextNamespace()) { if (n1.IsSamePosition(n2)) return XmlNodeOrder.Before; } return XmlNodeOrder.After; } if (ns1){ return XmlNodeOrder.After; } Debug.Assert(ns2); return XmlNodeOrder.Before; }
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); }
// XPath based comparison for namespaces, attributes and other // items with the same parent element. // // n2 // namespace(0) attribute(-1) other(-2) // n1 // namespace(0) ?(0) before(-1) before(-2) // attribute(1) after(1) ?(0) before(-1) // other (2) after(2) after(1) ?(0) private static XmlNodeOrder CompareSiblings(XPathNavigator n1, XPathNavigator n2) { int cmp = 0; #if DEBUG Debug.Assert(!n1.IsSamePosition(n2)); XPathNavigator p1 = n1.Clone(), p2 = n2.Clone(); Debug.Assert(p1.MoveToParent() && p2.MoveToParent() && p1.IsSamePosition(p2)); #endif switch (n1.NodeType) { case XPathNodeType.Namespace: break; case XPathNodeType.Attribute: cmp += 1; break; default: cmp += 2; break; } switch (n2.NodeType) { case XPathNodeType.Namespace: if (cmp == 0) { while (n1.MoveToNextNamespace()) { if (n1.IsSamePosition(n2)) { return XmlNodeOrder.Before; } } } break; case XPathNodeType.Attribute: cmp -= 1; if (cmp == 0) { while (n1.MoveToNextAttribute()) { if (n1.IsSamePosition(n2)) { return XmlNodeOrder.Before; } } } break; default: cmp -= 2; if (cmp == 0) { while (n1.MoveToNext()) { if (n1.IsSamePosition(n2)) { return XmlNodeOrder.Before; } } } break; } return cmp < 0 ? XmlNodeOrder.Before : XmlNodeOrder.After; }
/// <summary> /// Recursive helper function that reverses order of the namespaces retrieved by MoveToFirstNamespace and /// MoveToNextNamespace. /// </summary> private void CopyNamespacesHelper(XPathNavigator navigator, XPathNamespaceScope nsScope) { string prefix = navigator.LocalName; string ns = navigator.Value; if (navigator.MoveToNextNamespace(nsScope)) CopyNamespacesHelper(navigator, nsScope); // No possibility for conflict, since we're copying namespaces from well-formed element WriteNamespaceDeclarationUnchecked(prefix, ns); }
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); } }