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;
}
