public override void Evaluate (XslTransformProcessor p) { if (p.Debugger != null) p.Debugger.DebugExecute (p, this.DebugInput); p.CallTemplate (name, withParams); }
public override void Evaluate (XslTransformProcessor p) { if (p.Debugger != null) p.Debugger.DebugExecute (p, this.DebugInput); EvaluateIfTrue (p); }
public object Evaluate (XslTransformProcessor p) { if (select != null) { object o = p.Evaluate (select); // To resolve variable references correctly, we // have to collect all the target nodes here. // (otherwise, variables might be resolved with // different level of variable stack in // XslTransformProcessor). if (o is XPathNodeIterator) { ArrayList al = new ArrayList (); XPathNodeIterator iter = (XPathNodeIterator) o; while (iter.MoveNext ()) al.Add (iter.Current.Clone ()); o = new ListIterator (al, p.XPathContext); } return o; } else if (content != null) { DTMXPathDocumentWriter2 w = new DTMXPathDocumentWriter2 (p.Root.NameTable, 200); Outputter outputter = new GenericOutputter(w, p.Outputs, null, true); p.PushOutput (outputter); if (p.CurrentNodeset.CurrentPosition == 0) p.NodesetMoveNext (); content.Evaluate (p); p.PopOutput (); return w.CreateDocument ().CreateNavigator (); } else { return ""; } }
public override void Evaluate (XslTransformProcessor p) { if (p.Debugger != null) p.Debugger.DebugExecute (p, this.DebugInput); p.ApplyImports (); }
public override void Evaluate (XslTransformProcessor p) { if (p.Debugger != null) p.Debugger.DebugExecute (p, this.DebugInput); p.Out.WriteComment (value == null ? String.Empty : value.EvaluateAsString (p)); }
public override void Evaluate(XslTransformProcessor p) { if (p.Debugger != null) { p.Debugger.DebugExecute(p, this.DebugInput); } p.CallTemplate(name, withParams); }
public bool EvaluateIfTrue (XslTransformProcessor p) { if (p.EvaluateBoolean (test)) { if (children != null) children.Evaluate (p); return true; } return false; }
public override void Evaluate(XslTransformProcessor p) { if (p.Debugger != null) { p.Debugger.DebugExecute(p, base.DebugInput); } string text = (this.calcName == null) ? this.name.Evaluate(p) : this.calcName; string text2 = (this.calcNs == null) ? ((this.ns == null) ? null : this.ns.Evaluate(p)) : this.calcNs; XmlQualifiedName xmlQualifiedName = XslNameUtil.FromString(text, this.nsDecls); string text3 = xmlQualifiedName.Name; if (text2 == null) { text2 = xmlQualifiedName.Namespace; } int num = text.IndexOf(':'); if (num > 0) { this.calcPrefix = text.Substring(0, num); } else if (num == 0) { XmlConvert.VerifyNCName(string.Empty); } string text4 = (this.calcPrefix == null) ? string.Empty : this.calcPrefix; if (text4 != string.Empty) { XmlConvert.VerifyNCName(text4); } XmlConvert.VerifyNCName(text3); bool insideCDataElement = p.InsideCDataElement; p.PushElementState(text4, text3, text2, false); p.Out.WriteStartElement(text4, text3, text2); if (this.useAttributeSets != null) { foreach (XmlQualifiedName xmlQualifiedName2 in this.useAttributeSets) { p.ResolveAttributeSet(xmlQualifiedName2).Evaluate(p); } } if (this.value != null) { this.value.Evaluate(p); } if (this.isEmptyElement && this.useAttributeSets == null) { p.Out.WriteEndElement(); } else { p.Out.WriteFullEndElement(); } p.PopCDataState(insideCDataElement); }
public override void Evaluate(XslTransformProcessor p) { if (p.Debugger != null) { p.Debugger.DebugExecute(p, this.DebugInput); } p.ApplyImports(); }
public override void Evaluate(XslTransformProcessor p) { if (p.Debugger != null) { p.Debugger.DebugExecute(p, this.DebugInput); } p.SetStackItem(slot, var.Evaluate(p)); }
public override void Evaluate(XslTransformProcessor p) { if (p.Debugger != null) { p.Debugger.DebugExecute(p, this.DebugInput); } children.Evaluate(p); }
public override void Evaluate (XslTransformProcessor p) { if (p.Debugger != null) p.Debugger.DebugExecute (p, this.DebugInput); if (!disableOutputEscaping) p.Out.WriteString (p.EvaluateString (select)); else p.Out.WriteRaw (p.EvaluateString (select)); }
public virtual string EvaluateAsString (XslTransformProcessor p) { StringWriter sw = new StringWriter (); Outputter outputter = new TextOutputter (sw, true); p.PushOutput (outputter); Evaluate (p); p.PopOutput (); outputter.Done (); return sw.ToString (); }
public override void Evaluate (XslTransformProcessor p) { if (p.Debugger != null) p.Debugger.DebugExecute (p, this.DebugInput); if (children != null) output.Write (children.EvaluateAsString (p)); if (terminate) throw new XsltException ("Transformation terminated.", null, p.CurrentNode); }
public override void Evaluate(XslTransformProcessor p) { if (p.Debugger != null) { p.Debugger.DebugExecute(p, this.DebugInput); } p.Out.WriteComment(value == null ? String.Empty : value.EvaluateAsString(p)); }
public override void Evaluate(XslTransformProcessor p) { if (p.Debugger != null) { p.Debugger.DebugExecute(p, this.DebugInput); } string nm, nmsp, prefix; nm = calcName != null ? calcName : name.Evaluate(p); nmsp = calcNs != null ? calcNs : ns != null?ns.Evaluate(p) : String.Empty; prefix = calcPrefix != null ? calcPrefix : String.Empty; if (nm == "xmlns") { // It is an error. We must recover by not emmiting any attributes // (unless we throw an exception). return; } int colonAt = nm.IndexOf(':'); // local attribute if (colonAt > 0) { prefix = nm.Substring(0, colonAt); nm = nm.Substring(colonAt + 1); // global attribute if (nmsp == String.Empty && prefix == XmlNamespaceManager.PrefixXml) { nmsp = XmlNamespaceManager.XmlnsXml; } else if (nmsp == String.Empty) { nmsp = (string)nsDecls [prefix]; if (nmsp == null) { nmsp = String.Empty; } } } if (prefix == "xmlns") { prefix = String.Empty; // Should not be allowed. } XmlConvert.VerifyName(nm); p.Out.WriteAttributeString(prefix, nm, nmsp, value == null ? "" : value.EvaluateAsString(p)); }
int NumberSingle(XslTransformProcessor p) { XPathNavigator n = p.CurrentNode.Clone(); while (!MatchesCount(n, p)) { if (from != null && MatchesFrom(n, p)) { return(0); } if (!n.MoveToParent()) { return(0); } } if (from != null) { XPathNavigator tmp = n.Clone(); if (MatchesFrom(tmp, p)) { // Was not desc of closest matches from return(0); } bool found = false; while (tmp.MoveToParent()) { if (MatchesFrom(tmp, p)) { found = true; break; } } if (!found) { // not desc of matches from return(0); } } int i = 1; while (n.MoveToPrevious()) { if (MatchesCount(n, p)) { i++; } } return(i); }
bool MatchesFrom(XPathNavigator item, XslTransformProcessor p) { if (from == null) { return(item.NodeType == XPathNodeType.Root); } else { return(p.Matches(from, item)); } }
public virtual string EvaluateAsString(XslTransformProcessor p) { StringWriter sw = new StringWriter(); Outputter outputter = new TextOutputter(sw, true); p.PushOutput(outputter); Evaluate(p); p.PopOutput(); outputter.Done(); return(sw.ToString()); }
public bool EvaluateIfTrue(XslTransformProcessor p) { if (p.EvaluateBoolean(this.test)) { if (this.children != null) { this.children.Evaluate(p); } return(true); } return(false); }
public override void Evaluate (XslTransformProcessor p) { if (p.Debugger != null) p.Debugger.DebugExecute (p, this.DebugInput); if (fallbacks != null) { foreach (XslFallback f in fallbacks) f.Evaluate (p); } else throw new XsltException (String.Format ("'{0}' element is not supported as a template content in XSLT 1.0.", name), null); }
public override void Evaluate(XslTransformProcessor p) { if (p.Debugger != null) { p.Debugger.DebugExecute(p, base.DebugInput); } string text = this.GetFormat(p); if (text != string.Empty) { p.Out.WriteString(text); } }
bool MatchesCount(XPathNavigator item, XslTransformProcessor p) { if (count == null) { return(item.NodeType == p.CurrentNode.NodeType && item.LocalName == p.CurrentNode.LocalName && item.NamespaceURI == p.CurrentNode.NamespaceURI); } else { return(p.Matches(count, item)); } }
public override void Evaluate(XslTransformProcessor p) { if (p.Debugger != null) { p.Debugger.DebugExecute(p, this.DebugInput); } // Since namespace-alias might be determined after compilation // of import-ing stylesheets, this must be determined later. bool isCData = p.InsideCDataElement; p.PushElementState(prefix, localname, nsUri, true); p.Out.WriteStartElement(prefix, localname, nsUri); if (useAttributeSets != null) { foreach (XmlQualifiedName s in useAttributeSets) { p.ResolveAttributeSet(s).Evaluate(p); } } if (attrs != null) { int len = attrs.Count; for (int i = 0; i < len; i++) { ((XslLiteralAttribute)attrs [i]).Evaluate(p); } } p.OutputLiteralNamespaceUriNodes(nsDecls, null, null); if (children != null) { children.Evaluate(p); } var templateContent = children as XslTemplateContent; if (isEmptyElement || (templateContent != null && templateContent.IsEmptyElement)) { p.Out.WriteEndElement(); } else { p.Out.WriteFullEndElement(); } p.PopCDataState(isCData); }
public override void Evaluate (XslTransformProcessor p) { if (p.Debugger != null) p.Debugger.DebugExecute (p, this.DebugInput); if (!disableOutputEscaping) { if (isWhitespace) p.Out.WriteWhitespace (text); else p.Out.WriteString (text); } else p.Out.WriteRaw (text); }
public override void Evaluate(XslTransformProcessor p) { if (p.Debugger != null) { p.Debugger.DebugExecute(p, this.DebugInput); } string formatted = GetFormat(p); if (formatted != String.Empty) { p.Out.WriteString(formatted); } }
public override void Evaluate(XslTransformProcessor p) { if (p.Debugger != null) { p.Debugger.DebugExecute(p, base.DebugInput); } if (!this.disableOutputEscaping) { p.Out.WriteString(p.EvaluateString(this.select)); } else { p.Out.WriteRaw(p.EvaluateString(this.select)); } }
public override void Evaluate(XslTransformProcessor p) { if (p.Debugger != null) { p.Debugger.DebugExecute(p, base.DebugInput); } if (this.children != null) { XslMessage.output.Write(this.children.EvaluateAsString(p)); } if (this.terminate) { throw new XsltException("Transformation terminated.", null, p.CurrentNode); } }
public override void Evaluate (XslTransformProcessor p) { if (p.Debugger != null) p.Debugger.DebugExecute (p, this.DebugInput); string actualName = name.Evaluate (p); if (String.Compare (actualName, "xml", true, CultureInfo.InvariantCulture) == 0) throw new XsltException ("Processing instruction name was evaluated to \"xml\"", null, p.CurrentNode); if (actualName.IndexOf (':') >= 0) return; //MS.NET ignores such processing instructions p.Out.WriteProcessingInstruction (actualName, value == null ? String.Empty : value.EvaluateAsString (p)); }
public override void Evaluate(XslTransformProcessor p) { if (p.Debugger != null) { p.Debugger.DebugExecute(p, base.DebugInput); } if (this.select == null) { p.ApplyTemplates(p.CurrentNode.SelectChildren(XPathNodeType.All), this.mode, this.withParams); } else { XPathNodeIterator nodes = (this.sortEvaluator == null) ? p.Select(this.select) : this.sortEvaluator.SortedSelect(p); p.ApplyTemplates(nodes, this.mode, this.withParams); } }
private int NumberSingle(XslTransformProcessor p) { XPathNavigator xpathNavigator = p.CurrentNode.Clone(); while (!this.MatchesCount(xpathNavigator, p)) { if (this.from != null && this.MatchesFrom(xpathNavigator, p)) { return(0); } if (!xpathNavigator.MoveToParent()) { return(0); } } if (this.from != null) { XPathNavigator xpathNavigator2 = xpathNavigator.Clone(); if (this.MatchesFrom(xpathNavigator2, p)) { return(0); } bool flag = false; while (xpathNavigator2.MoveToParent()) { if (this.MatchesFrom(xpathNavigator2, p)) { flag = true; break; } } if (!flag) { return(0); } } int num = 1; while (xpathNavigator.MoveToPrevious()) { if (this.MatchesCount(xpathNavigator, p)) { num++; } } return(num); }
public override void Evaluate(XslTransformProcessor p) { if (p.Debugger != null) { p.Debugger.DebugExecute(p, base.DebugInput); } if (this.fallbacks != null) { foreach (object obj in this.fallbacks) { XslFallback xslFallback = (XslFallback)obj; xslFallback.Evaluate(p); } return; } throw new XsltException(string.Format("'{0}' element is not supported as a template content in XSLT 1.0.", this.name), null); }
public override void Evaluate(XslTransformProcessor p) { if (p.Debugger != null) { p.Debugger.DebugExecute(p, base.DebugInput); } XPathNodeIterator xpathNodeIterator = (this.sortEvaluator == null) ? p.Select(this.select) : this.sortEvaluator.SortedSelect(p); while (p.NodesetMoveNext(xpathNodeIterator)) { p.PushNodeset(xpathNodeIterator); p.PushForEachContext(); this.children.Evaluate(p); p.PopForEachContext(); p.PopNodeset(); } }
public override void Evaluate(XslTransformProcessor p) { if (p.Debugger != null) { p.Debugger.DebugExecute(p, base.DebugInput); } string text = this.name.Evaluate(p); if (string.Compare(text, "xml", true, CultureInfo.InvariantCulture) == 0) { throw new XsltException("Processing instruction name was evaluated to \"xml\"", null, p.CurrentNode); } if (text.IndexOf(':') >= 0) { return; } p.Out.WriteProcessingInstruction(text, (this.value != null) ? this.value.EvaluateAsString(p) : string.Empty); }
int [] NumberMultiple(XslTransformProcessor p) { ArrayList nums = new ArrayList(); XPathNavigator n = p.CurrentNode.Clone(); bool foundFrom = false; do { if (MatchesFrom(n, p)) { foundFrom = true; break; } if (MatchesCount(n, p)) { int i = 1; while (n.MoveToPrevious()) { if (MatchesCount(n, p)) { i++; } } nums.Add(i); } }while (n.MoveToParent()); if (!foundFrom) { return(new int [0]); } int [] ret = new int [nums.Count]; int pos = nums.Count; for (int i = 0; i < nums.Count; i++) { ret [--pos] = (int)nums [i]; } return(ret); }
public string Evaluate(XslTransformProcessor p) { if (this.simpleString != null) { return(this.simpleString); } if (this.avtParts.Count == 1) { return(((XslAvt.AvtPart) this.avtParts[0]).Evaluate(p)); } StringBuilder avtStringBuilder = p.GetAvtStringBuilder(); int count = this.avtParts.Count; for (int i = 0; i < count; i++) { avtStringBuilder.Append(((XslAvt.AvtPart) this.avtParts[i]).Evaluate(p)); } return(p.ReleaseAvtStringBuilder()); }
public override void Evaluate(XslTransformProcessor p) { if (p.Debugger != null) { p.Debugger.DebugExecute(p, base.DebugInput); } Hashtable globalVariableTable = p.globalVariableTable; if (!globalVariableTable.Contains(this)) { globalVariableTable[this] = XslGlobalVariable.busyObject; globalVariableTable[this] = this.var.Evaluate(p); return; } if (globalVariableTable[this] == XslGlobalVariable.busyObject) { throw new XsltException("Circular dependency was detected", null, p.CurrentNode); } }
public override void Evaluate(XslTransformProcessor p) { if (p.Debugger != null) { p.Debugger.DebugExecute(p, this.DebugInput); } if (fallbacks != null) { foreach (XslFallback f in fallbacks) { f.Evaluate(p); } } else { throw new XsltException(String.Format("'{0}' element is not supported as a template content in XSLT 1.0.", name), null); } }
public override void Evaluate(XslTransformProcessor p) { if (p.Debugger != null) { p.Debugger.DebugExecute(p, this.DebugInput); } if (select == null) { p.ApplyTemplates(p.CurrentNode.SelectChildren(XPathNodeType.All), mode, withParams); } else { XPathNodeIterator iter = sortEvaluator != null? sortEvaluator.SortedSelect(p) : p.Select(select); p.ApplyTemplates(iter, mode, withParams); } }
public override void Evaluate(XslTransformProcessor p) { if (p.Debugger != null) { p.Debugger.DebugExecute(p, base.DebugInput); } int count = this.conditions.Count; for (int i = 0; i < count; i++) { if (((XslIf)this.conditions[i]).EvaluateIfTrue(p)) { return; } } if (this.defaultChoice != null) { this.defaultChoice.Evaluate(p); } }
public object Evaluate(XslTransformProcessor p) { if (select != null) { object o = p.Evaluate(select); // To resolve variable references correctly, we // have to collect all the target nodes here. // (otherwise, variables might be resolved with // different level of variable stack in // XslTransformProcessor). if (o is XPathNodeIterator) { ArrayList al = new ArrayList(); XPathNodeIterator iter = (XPathNodeIterator)o; while (iter.MoveNext()) { al.Add(iter.Current.Clone()); } o = new ListIterator(al, p.XPathContext); } return(o); } else if (content != null) { // XmlNodeWriter w = new XmlNodeWriter (false); // DTMXPathDocumentWriter w = new DTMXPathDocumentWriter (p.CurrentNode.NameTable, 200); DTMXPathDocumentWriter2 w = new DTMXPathDocumentWriter2(p.CurrentNode.NameTable, 200); Outputter outputter = new GenericOutputter(w, p.Outputs, null, true); p.PushOutput(outputter); content.Evaluate(p); p.PopOutput(); // return w.Document.CreateNavigator ().SelectChildren (XPathNodeType.All); // return w.CreateDocument ().CreateNavigator ().SelectChildren (XPathNodeType.All); // return w.Document.CreateNavigator (); return(w.CreateDocument().CreateNavigator()); } else { return(""); } }
XslNumberFormatter GetNumberFormatter(XslTransformProcessor p) { string formatStr = "1"; string lang = null; string letterValue = null; char groupingSeparatorChar = '\0'; decimal groupingSize = 0; if (this.format != null) { formatStr = this.format.Evaluate(p); } if (this.lang != null) { lang = this.lang.Evaluate(p); } if (this.letterValue != null) { letterValue = this.letterValue.Evaluate(p); } if (groupingSeparator != null) { groupingSeparatorChar = this.groupingSeparator.Evaluate(p) [0]; } if (this.groupingSize != null) { groupingSize = decimal.Parse(this.groupingSize.Evaluate(p), CultureInfo.InvariantCulture); } //FIXME: Negative test compliency: .NET throws exception on negative grouping-size if (groupingSize > Int32.MaxValue || groupingSize < 1) { groupingSize = 0; } return(new XslNumberFormatter(formatStr, lang, letterValue, groupingSeparatorChar, (int)groupingSize)); }
public override void Evaluate (XslTransformProcessor p) { if (p.Debugger != null) p.Debugger.DebugExecute (p, this.DebugInput); // This intelligent optimization causes poor compatibility bug shown in bug #457065 // if (children == null) // return; XPathNodeIterator iter = sortEvaluator != null ? sortEvaluator.SortedSelect (p) : p.Select (select); while (p.NodesetMoveNext (iter)) { p.PushNodeset (iter); p.PushForEachContext (); children.Evaluate (p); p.PopForEachContext(); p.PopNodeset (); } }
public abstract string Evaluate (XslTransformProcessor p);
public void Override (XslTransformProcessor p, object paramVal) { p.SetStackItem (slot, paramVal); }
public override void Evaluate (XslTransformProcessor p) { if (p.Debugger != null) p.Debugger.DebugExecute (p, this.DebugInput); if (p.GetStackItem (slot) != null) return; // evaluated already if (p.Arguments != null && var.Select == null && var.Content == null) { object val = p.Arguments.GetParam (Name.Name, Name.Namespace); if (val != null) { Override (p, val); return; } } base.Evaluate (p); }
public bool IsEvaluated (XslTransformProcessor p) { return p.GetStackItem (slot) != null; }
protected override object GetValue (XslTransformProcessor p) { return p.GetStackItem (slot); }
public override void Evaluate (XslTransformProcessor p) { if (p.Debugger != null) p.Debugger.DebugExecute (p, this.DebugInput); p.SetStackItem (slot, var.Evaluate (p)); }
public void Override (XslTransformProcessor p, object paramVal) { Debug.Assert (!p.globalVariableTable.Contains (this), "Shouldn't have been evaluated by this point"); p.globalVariableTable [this] = paramVal; }
protected override object GetValue (XslTransformProcessor p) { p.PushNodeset (new SelfIterator (p.Root, p.XPathContext)); p.NodesetMoveNext (); Evaluate (p); p.PopNodeset (); return p.globalVariableTable [this]; }
public override void Evaluate (XslTransformProcessor p) { if (p.Debugger != null) p.Debugger.DebugExecute (p, this.DebugInput); Hashtable varInfo = p.globalVariableTable; if (varInfo.Contains (this)) { if (varInfo [this] == busyObject) throw new XsltException ("Circular dependency was detected", null, p.CurrentNode); return; } varInfo [this] = busyObject; varInfo [this] = var.Evaluate (p); }
protected abstract object GetValue (XslTransformProcessor p);
public override abstract void Evaluate (XslTransformProcessor p);
public override void Evaluate (XslTransformProcessor p) { if (p.Debugger != null) p.Debugger.DebugExecute (p, this.DebugInput); string nm, nmsp, prefix; nm = calcName != null ? calcName : name.Evaluate (p); nmsp = calcNs != null ? calcNs : ns != null ? ns.Evaluate (p) : String.Empty; prefix = calcPrefix != null ? calcPrefix : String.Empty; if (nm == "xmlns") // It is an error. We must recover by not emmiting any attributes // (unless we throw an exception). return; int colonAt = nm.IndexOf (':'); // local attribute if (colonAt > 0) { prefix = nm.Substring (0, colonAt); nm = nm.Substring (colonAt + 1); // global attribute if (nmsp == String.Empty && prefix == XmlNamespaceManager.PrefixXml) nmsp = XmlNamespaceManager.XmlnsXml; else if (nmsp == String.Empty) { nmsp = (string) nsDecls [prefix]; if (nmsp == null) nmsp = String.Empty; } } if (prefix == "xmlns") prefix = String.Empty; // Should not be allowed. XmlConvert.VerifyName (nm); p.Out.WriteAttributeString (prefix, nm, nmsp, value == null ? "" : value.EvaluateAsString (p)); }
public override string Evaluate (XslTransformProcessor p) { return p.EvaluateString (expr); }
protected override object GetValue (XslTransformProcessor p) { Evaluate (p); return p.globalVariableTable [this]; }
public string Evaluate (XslTransformProcessor p) { if (simpleString != null) return simpleString; if (avtParts.Count == 1) return ((AvtPart) avtParts [0]).Evaluate (p); StringBuilder sb = p.GetAvtStringBuilder (); int len = avtParts.Count; for (int i = 0; i < len; i++) sb.Append (((AvtPart) avtParts [i]).Evaluate (p)); return p.ReleaseAvtStringBuilder (); }
public override void Evaluate (XslTransformProcessor p) { if (p.Debugger != null) p.Debugger.DebugExecute (p, this.DebugInput); XPathNavigator nav = p.CurrentNode; switch (nav.NodeType) { case XPathNodeType.Root: if (p.Out.CanProcessAttributes && useAttributeSets != null) foreach (XmlQualifiedName s in useAttributeSets) { XslAttributeSet attset = p.ResolveAttributeSet (s); if (attset == null) throw new XsltException ("Attribute set was not found", null, nav); attset.Evaluate (p); } if (children != null) children.Evaluate (p); break; case XPathNodeType.Element: bool isCData = p.InsideCDataElement; string prefix = nav.Prefix; p.PushElementState (prefix, nav.LocalName, nav.NamespaceURI, true); p.Out.WriteStartElement (prefix, nav.LocalName, nav.NamespaceURI); if (useAttributeSets != null) foreach (XmlQualifiedName s in useAttributeSets) p.ResolveAttributeSet (s).Evaluate (p); if (nav.MoveToFirstNamespace (XPathNamespaceScope.ExcludeXml)) { do { if (nav.LocalName == prefix) continue; p.Out.WriteNamespaceDecl (nav.LocalName, nav.Value); } while (nav.MoveToNextNamespace (XPathNamespaceScope.ExcludeXml)); nav.MoveToParent (); } if (children != null) children.Evaluate (p); p.Out.WriteFullEndElement (); p.PopCDataState (isCData); break; case XPathNodeType.Attribute: p.Out.WriteAttributeString (nav.Prefix, nav.LocalName, nav.NamespaceURI, nav.Value); break; case XPathNodeType.SignificantWhitespace: case XPathNodeType.Whitespace: bool cdata = p.Out.InsideCDataSection; p.Out.InsideCDataSection = false; p.Out.WriteString (nav.Value); p.Out.InsideCDataSection = cdata; break; case XPathNodeType.Text: p.Out.WriteString (nav.Value); break; case XPathNodeType.Comment: p.Out.WriteComment (nav.Value); break; case XPathNodeType.ProcessingInstruction: p.Out.WriteProcessingInstruction (nav.Name, nav.Value); break; case XPathNodeType.Namespace: if (p.XPathContext.ElementPrefix != nav.Name) p.Out.WriteNamespaceDecl (nav.Name, nav.Value); break; default: // Console.WriteLine ("unhandled node type {0}", nav.NodeType); break; } }
public override string Evaluate (XslTransformProcessor p) { return val; }