far.
svn path=/trunk/mcs/; revision=118710
+2008-10-02 Atsushi Enomoto <atsushi@ximian.com>
+
+ * XslVariable.cs : now XPathNodeIterator.Current is always null at
+ position 0, so reduced dependency on it.
+ * XslCopy.cs : now CurrentNode property cannot be moved, so copy it
+ to a local variable.
+
2008-06-03 Atsushi Enomoto <atsushi@ximian.com>
* XslVariable.cs : In XslGeneralVariable.Evaluate(), always wrap
if (p.Debugger != null)
p.Debugger.DebugExecute (p, this.DebugInput);
- switch (p.CurrentNode.NodeType)
+ 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, p.CurrentNode);
+ throw new XsltException ("Attribute set was not found", null, nav);
attset.Evaluate (p);
}
break;
case XPathNodeType.Element:
bool isCData = p.InsideCDataElement;
- string prefix = p.CurrentNode.Prefix;
- p.PushElementState (prefix, p.CurrentNode.LocalName, p.CurrentNode.NamespaceURI, true);
- p.Out.WriteStartElement (prefix, p.CurrentNode.LocalName, p.CurrentNode.NamespaceURI);
+ 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 (p.CurrentNode.MoveToFirstNamespace (XPathNamespaceScope.ExcludeXml)) {
+ if (nav.MoveToFirstNamespace (XPathNamespaceScope.ExcludeXml)) {
do {
- if (p.CurrentNode.LocalName == prefix)
+ if (nav.LocalName == prefix)
continue;
- p.Out.WriteNamespaceDecl (p.CurrentNode.LocalName, p.CurrentNode.Value);
- } while (p.CurrentNode.MoveToNextNamespace (XPathNamespaceScope.ExcludeXml));
- p.CurrentNode.MoveToParent ();
+ p.Out.WriteNamespaceDecl (nav.LocalName, nav.Value);
+ } while (nav.MoveToNextNamespace (XPathNamespaceScope.ExcludeXml));
+ nav.MoveToParent ();
}
if (children != null) children.Evaluate (p);
p.PopCDataState (isCData);
break;
case XPathNodeType.Attribute:
- p.Out.WriteAttributeString (p.CurrentNode.Prefix, p.CurrentNode.LocalName, p.CurrentNode.NamespaceURI, p.CurrentNode.Value);
+ 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 (p.CurrentNode.Value);
+ p.Out.WriteString (nav.Value);
p.Out.InsideCDataSection = cdata;
break;
case XPathNodeType.Text:
- p.Out.WriteString (p.CurrentNode.Value);
+ p.Out.WriteString (nav.Value);
break;
case XPathNodeType.Comment:
- p.Out.WriteComment (p.CurrentNode.Value);
+ p.Out.WriteComment (nav.Value);
break;
case XPathNodeType.ProcessingInstruction:
- p.Out.WriteProcessingInstruction (p.CurrentNode.Name, p.CurrentNode.Value);
+ p.Out.WriteProcessingInstruction (nav.Name, nav.Value);
break;
case XPathNodeType.Namespace:
- if (p.XPathContext.ElementPrefix != p.CurrentNode.Name)
- p.Out.WriteNamespaceDecl (p.CurrentNode.Name, p.CurrentNode.Value);
+ if (p.XPathContext.ElementPrefix != nav.Name)
+ p.Out.WriteNamespaceDecl (nav.Name, nav.Value);
break;
default:
-// Console.WriteLine ("unhandled node type {0}", p.CurrentNode.NodeType);
+// Console.WriteLine ("unhandled node type {0}", nav.NodeType);
break;
}
}
}
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);
+ 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.Document.CreateNavigator ().SelectChildren (XPathNodeType.All);
-// return w.CreateDocument ().CreateNavigator ().SelectChildren (XPathNodeType.All);
-// return w.Document.CreateNavigator ();
return w.CreateDocument ().CreateNavigator ();
} else {
return "";
+2008-10-03 Atsushi Enomoto <atsushi@ximian.com>
+
+ * XslTransformProcessor.cs : reduce BaseIterator dependency.
+
+2008-10-02 Atsushi Enomoto <atsushi@ximian.com>
+
+ * GenericOutputter.cs : fix dummy namespace generation. (It might be
+ extraneous change and might be reverted later.)
+ * XslTransformProcessor.cs : some EvaluateXxx ()changes that may
+ be enabled later. Reduce BaseIterator dependency.
+ * XslFunctions.cs : reduce bad uses of "as" operator.
+ * XslKey.cs : Evaluate() result may be null now.
+
2008-06-03 Atsushi Enomoto <atsushi@ximian.com>
* XsltDebuggerWrapper.cs : allow public methods in debugger instance.
prefix = existing;
if (attr.Namespace.Length > 0) {
if (prefix == null || prefix == String.Empty)
+ { // ADD
// empty prefix is not allowed
// for non-local attributes.
prefix = "xp_" + _xpCount++;
- if (existing != prefix) {
+ //if (existing != prefix) {
while (_nsManager.LookupNamespace (prefix) != null)
prefix = "xp_" + _xpCount++;
newNamespaces.Add (prefix);
_currentNamespaceDecls.Add (prefix, attr.Namespace);
_nsManager.AddNamespace (prefix, attr.Namespace);
- }
+ //}
+ } // ADD
}
Emitter.WriteAttributeString (prefix, attr.LocalName, attr.Namespace, attr.Value);
}
public override object Evaluate (BaseIterator iter)
{
- return new SelfIterator ((iter.NamespaceManager as XsltCompiledContext).Processor.CurrentNode, null);
+ XsltCompiledContext ctx = (XsltCompiledContext) iter.NamespaceManager;
+ return new SelfIterator ((ctx).Processor.CurrentNode, ctx);
}
internal override bool Peer {
nm = XslNameUtil.FromString (arg2.EvaluateString (iter), ctx);
try {
- return (iter.NamespaceManager as XsltCompiledContext).Processor.CompiledStyle
+ return ((XsltCompiledContext) iter.NamespaceManager).Processor.CompiledStyle
.LookupDecimalFormat (nm).FormatNumber (d, s);
} catch (ArgumentException ex) {
throw new XsltException (ex.Message, ex, iter.Current);
iter, result, tmp);
}
}
- else {
+ else if (nav != null) {
ArrayList nodes = GetNodesByValue (
nav, XPathFunctions.ToString (o), ctx);
if (nodes != null)
// this.outputStylesheetXmlns = true;
this.currentOutputUri = String.Empty;
- XPathExpression exp = root.Compile (".");
- PushNodeset (root.Select (exp, this.XPathContext));
+ PushNodeset (new SelfIterator (root, this.XPathContext));
+CurrentNodeset.MoveNext ();
// have to evaluate the params first, as Global vars may
// be dependant on them
PopNodeset ();
this.PushOutput (outputtter);
- this.ApplyTemplates (root.Select (exp, this.XPathContext), QName.Empty, null);
+ this.ApplyTemplates (new SelfIterator (root, this.XPathContext), QName.Empty, null);
this.PopOutput ();
}
public CompiledStylesheet CompiledStyle { get { return compiledStyle; }}
public XsltArgumentList Arguments {get{return args;}}
-
+
+ public XPathNavigator Root { get { return root; } }
+
public MSXslScriptManager ScriptManager {
get { return compiledStyle.ScriptManager; }
}
public void PushNodeset (XPathNodeIterator itr)
{
- nodesetStack.Add (itr);
+ BaseIterator bi = itr as BaseIterator;
+ bi = bi != null ? bi : new WrapperIterator (itr, null);
+ bi.NamespaceManager = XPathContext;
+ nodesetStack.Add (bi);
}
public void PopNodeset ()
public object Evaluate (XPathExpression expr)
{
XPathNodeIterator itr = CurrentNodeset;
- return itr.Current.Evaluate (expr, itr, XPathContext);
+ BaseIterator bi = (BaseIterator) itr;
+ CompiledExpression cexpr = (CompiledExpression) expr;
+ if (bi.NamespaceManager == null)
+ bi.NamespaceManager = cexpr.NamespaceManager;
+ return cexpr.Evaluate (bi);
}
public string EvaluateString (XPathExpression expr)
{
XPathNodeIterator itr = CurrentNodeset;
+#if true
return itr.Current.EvaluateString (expr, itr, XPathContext);
+#else
+ BaseIterator bi = (BaseIterator) itr;
+ CompiledExpression cexpr = (CompiledExpression) expr;
+ if (bi.NamespaceManager == null)
+ bi.NamespaceManager = cexpr.NamespaceManager;
+ return cexpr.EvaluateString (bi);
+#endif
}
public bool EvaluateBoolean (XPathExpression expr)
{
XPathNodeIterator itr = CurrentNodeset;
+#if true
return itr.Current.EvaluateBoolean (expr, itr, XPathContext);
+#else
+ BaseIterator bi = (BaseIterator) itr;
+ CompiledExpression cexpr = (CompiledExpression) expr;
+ if (bi.NamespaceManager == null)
+ bi.NamespaceManager = cexpr.NamespaceManager;
+ return cexpr.EvaluateBoolean (bi);
+#endif
}
public double EvaluateNumber (XPathExpression expr)
{
XPathNodeIterator itr = CurrentNodeset;
+#if true
return itr.Current.EvaluateNumber (expr, itr, XPathContext);
+#else
+ BaseIterator bi = (BaseIterator) itr;
+ CompiledExpression cexpr = (CompiledExpression) expr;
+ if (bi.NamespaceManager == null)
+ bi.NamespaceManager = cexpr.NamespaceManager;
+ return cexpr.EvaluateNumber (bi);
+#endif
}
public XPathNodeIterator Select (XPathExpression expr)
{
+#if true
return CurrentNodeset.Current.Select (expr, XPathContext);
+#else
+ BaseIterator bi = (BaseIterator) CurrentNodeset;
+ CompiledExpression cexpr = (CompiledExpression) expr;
+ if (bi.NamespaceManager == null)
+ bi.NamespaceManager = cexpr.NamespaceManager;
+ return cexpr.EvaluateNodeSet (bi);
+#endif
}
#endregion
+2008-10-08 Atsushi Enomoto <atsushi@ximian.com>
+
+ * Expression.cs : fix WeakReference usage for such case that it
+ might GC-ed between .IsAlive check and .Target retrieval.
+
+2008-10-06 Atsushi Enomoto <atsushi@ximian.com>
+
+ * XPathExpression.cs, Expression.cs : Cache compiled xpath
+ expressions so that they don't have to be parsed repeatedly.
+
+2008-10-06 Atsushi Enomoto <atsushi@ximian.com>
+
+ * Expression.cs : unindend cases that do not match our coding style.
+
+2008-10-06 Atsushi Enomoto <atsushi@ximian.com>
+
+ * Expression.cs : fixed peer & subtree requirement and reduced extra
+ dependency on RequireSorting property.
+
+2008-10-06 Atsushi Enomoto <atsushi@ximian.com>
+
+ * Expression.cs, Iterator.cs : simplify SlashIterator by introducing
+ SortedIterator.
+
+2008-10-06 Atsushi Enomoto <atsushi@ximian.com>
+
+ * Expression.cs, Iterator.cs : ChildIterator is not a SimpleIterator
+ now. And reduced extra clone when the context node has no child.
+
+2008-10-03 Atsushi Enomoto <atsushi@ximian.com>
+
+ * Iterator.cs : now we do not seem to need clone in
+ SimpleIterator.Current.
+
+2008-10-03 Atsushi Enomoto <atsushi@ximian.com>
+
+ * XPathNavigator.cs : enable EnumerableIterator with some fixes.
+ * Iterator.cs : reduce extra steps for empty simple iterator.
+
+2008-10-02 Atsushi Enomoto <atsushi@ximian.com>
+
+ * Iterator.cs, DefaultContext.cs, XPathNavigator.cs, Expression.cs:
+ couple of refactoring: reduced presumption on BaseIterator (it is
+ premised in not a few places, but it might change; see
+ EnumerableIterator in XPathNavigator.cs).
+ Now BaseIterator.Current is always null (to clean up ambiguous
+ implementation state). Current property is now always moved to
+ the current node in the iterator when returned.
+
2008-09-19 Atsushi Enomoto <atsushi@ximian.com>
* DefaultContext.cs, Expression.cs: do not premise BaseIterator.
String strArgs;
object val = arg0.Evaluate (iter);
- BaseIterator valItr = val as BaseIterator;
+ XPathNodeIterator valItr = val as XPathNodeIterator;
if (valItr != null)
{
strArgs = "";
namespace System.Xml.XPath
{
+ internal static class ExpressionCache
+ {
+ static readonly Hashtable table_per_ctx = new Hashtable ();
+ static object dummy = new object ();
+
+ public static XPathExpression Get (string xpath, IStaticXsltContext ctx)
+ {
+ object ctxkey = ctx != null ? ctx : dummy;
+
+ WeakReference wr = table_per_ctx [ctxkey] as WeakReference;
+ if (wr == null)
+ return null;
+ if (!wr.IsAlive) {
+ table_per_ctx [ctxkey] = null;
+ return null;
+ }
+ Hashtable table = (Hashtable) wr.Target;
+
+ wr = table [xpath] as WeakReference;
+ if (wr != null) {
+ if (wr.IsAlive)
+ // it may return null (as it might be GC-ed), but we don't have to worrt about it here.
+ return (XPathExpression) wr.Target;
+ table [xpath] = null;
+ }
+ return null;
+ }
+
+ public static void Set (string xpath, IStaticXsltContext ctx, XPathExpression exp)
+ {
+ object ctxkey = ctx != null ? ctx : dummy;
+
+ Hashtable table = null;
+
+ WeakReference wr = table_per_ctx [ctxkey] as WeakReference;
+ if (wr != null && wr.IsAlive)
+ table = (Hashtable) wr.Target;
+ if (table == null) {
+ table = new Hashtable ();
+ table_per_ctx [ctxkey] = new WeakReference (table);
+ }
+ table [xpath] = new WeakReference (exp);
+ }
+ }
+
#if XPATH_DEBUG
internal class CompiledExpression : Test.Xml.XPath.XPathExpression
#else
if (_sorters != null)
return EvaluateNodeSet (iter);
+#if false
+ return _expr.Evaluate (iter);
+#else
try {
return _expr.Evaluate (iter);
}
catch (Exception e) {
throw new XPathException ("Error during evaluation", e);
}
+#endif
}
public XPathNodeIterator EvaluateNodeSet (BaseIterator iter)
{
case XPathResultType.Any:
case XPathResultType.Navigator: // FIXME: It may pass not-allowed use of RTF
object o = Evaluate (iter);
- BaseIterator iterResult = o as BaseIterator;
- if (iterResult != null)
+ XPathNodeIterator xi = o as XPathNodeIterator;
+ BaseIterator iterResult = null;
+ if (xi != null) {
+ iterResult = xi as BaseIterator;
+ if (iterResult == null)
+ iterResult = new WrapperIterator (xi, iter.NamespaceManager);
return iterResult;
+ }
XPathNavigator nav = o as XPathNavigator;
if (nav != null) {
XPathNodeIterator xiter = nav.SelectChildren (XPathNodeType.All);
if (type == XPathResultType.Any)
type = GetReturnType (result);
- switch (type)
- {
- case XPathResultType.Number:
- return (double)result;
- case XPathResultType.Boolean:
- return ((bool) result) ? 1.0 : 0.0;
- case XPathResultType.NodeSet:
- return XPathFunctions.ToNumber (EvaluateString (iter));
- case XPathResultType.String:
- return XPathFunctions.ToNumber ((string) result);
- case XPathResultType.Navigator:
- return XPathFunctions.ToNumber (((XPathNavigator) (result)).Value);
- default:
- throw new XPathException ("invalid node type");
+ switch (type) {
+ case XPathResultType.Number:
+ return (double)result;
+ case XPathResultType.Boolean:
+ return ((bool) result) ? 1.0 : 0.0;
+ case XPathResultType.NodeSet:
+ return XPathFunctions.ToNumber (EvaluateString (iter));
+ case XPathResultType.String:
+ return XPathFunctions.ToNumber ((string) result);
+ case XPathResultType.Navigator:
+ return XPathFunctions.ToNumber (((XPathNavigator) (result)).Value);
+ default:
+ throw new XPathException ("invalid node type");
}
}
XPathResultType type = GetReturnType (iter);
if (type == XPathResultType.Any)
type = GetReturnType (result);
- switch (type)
+ switch (type) {
+ case XPathResultType.Number:
+ double d = (double) result;
+ return XPathFunctions.ToString (d);
+ case XPathResultType.Boolean:
+ return ((bool) result) ? "true" : "false";
+ case XPathResultType.String:
+ return (string) result;
+ case XPathResultType.NodeSet:
{
- case XPathResultType.Number:
- double d = (double) result;
- return XPathFunctions.ToString (d);
- case XPathResultType.Boolean:
- return ((bool) result) ? "true" : "false";
- case XPathResultType.String:
- return (string) result;
- case XPathResultType.NodeSet:
- {
- BaseIterator iterResult = (BaseIterator) result;
- if (iterResult == null || !iterResult.MoveNext ())
- return "";
- return iterResult.Current.Value;
- }
- case XPathResultType.Navigator:
- return ((XPathNavigator) result).Value;
- default:
- throw new XPathException ("invalid node type");
+ BaseIterator iterResult = (BaseIterator) result;
+ if (iterResult == null || !iterResult.MoveNext ())
+ return "";
+ return iterResult.Current.Value;
+ }
+ case XPathResultType.Navigator:
+ return ((XPathNavigator) result).Value;
+ default:
+ throw new XPathException ("invalid node type");
}
}
XPathResultType type = GetReturnType (iter);
if (type == XPathResultType.Any)
type = GetReturnType (result);
- switch (type)
- {
- case XPathResultType.Number:
- {
- double num = Convert.ToDouble (result);
- return (num != 0.0 && num != -0.0 && !Double.IsNaN (num));
- }
- case XPathResultType.Boolean:
- return (bool) result;
- case XPathResultType.String:
- return ((string) result).Length != 0;
- case XPathResultType.NodeSet:
- {
- BaseIterator iterResult = (BaseIterator) result;
- return (iterResult != null && iterResult.MoveNext ());
- }
- case XPathResultType.Navigator:
- return (((XPathNavigator) result).HasChildren);
- default:
- throw new XPathException ("invalid node type");
+ switch (type) {
+ case XPathResultType.Number:
+ double num = Convert.ToDouble (result);
+ return (num != 0.0 && num != -0.0 && !Double.IsNaN (num));
+ case XPathResultType.Boolean:
+ return (bool) result;
+ case XPathResultType.String:
+ return ((string) result).Length != 0;
+ case XPathResultType.NodeSet:
+ BaseIterator iterResult = (BaseIterator) result;
+ return (iterResult != null && iterResult.MoveNext ());
+ case XPathResultType.Navigator:
+ return (((XPathNavigator) result).HasChildren);
+ default:
+ throw new XPathException ("invalid node type");
}
}
public object EvaluateAs (BaseIterator iter, XPathResultType type)
{
- switch (type)
- {
+ switch (type) {
case XPathResultType.Boolean:
return EvaluateBoolean (iter);
case XPathResultType.NodeSet:
// Peer and subtree optimization. see
// http://idealliance.org/papers/dx_xmle04/papers/02-03-02/02-03-02.html
BaseIterator iterLeft = left.EvaluateNodeSet (iter);
- if (left.Peer && right.Subtree && !RequireSorting)
+ if (left.Peer && right.Subtree)
return new SimpleSlashIterator (iterLeft, right);
- return new SlashIterator (iterLeft, right, RequireSorting);
+ BaseIterator si = new SlashIterator (iterLeft, right);
+ return RequireSorting ? new SortedIterator (si) : si;
}
public override bool RequireSorting { get { return left.RequireSorting || right.RequireSorting; } }
if (left.Peer && !left.RequireSorting)
il = new SimpleSlashIterator (
il, DescendantOrSelfStar);
- else
- il = new SlashIterator (il,
- DescendantOrSelfStar,
- left.RequireSorting);
+ else {
+ BaseIterator bb = new SlashIterator (il, DescendantOrSelfStar);
+ il = left.RequireSorting ? new SortedIterator (bb) : bb;
+ }
- return new SlashIterator (
- il,
- right,
- DescendantOrSelfStar.RequireSorting || right.RequireSorting
- );
+ SlashIterator b = new SlashIterator (il, right);
+ return RequireSorting ? (BaseIterator) new SortedIterator (b) : b;
}
public override bool RequireSorting { get { return left.RequireSorting || right.RequireSorting; } }
public override String ToString () { return ""; }
public override object Evaluate (BaseIterator iter)
{
+ if (iter.CurrentPosition == 0) {
+ iter = (BaseIterator) iter.Clone ();
+ iter.MoveNext ();
+ }
XPathNavigator navRoot = iter.Current.Clone ();
navRoot.MoveToRoot ();
return new SelfIterator (navRoot, iter.NamespaceManager);
{
get
{
- switch (_axis)
- {
+ switch (_axis) {
case Axes.Namespace:
return XPathNodeType.Namespace;
case Axes.Attribute:
}
public override string ToString ()
{
- switch (_axis)
- {
- case Axes.Ancestor:
- return "ancestor";
- case Axes.AncestorOrSelf:
- return "ancestor-or-self";
- case Axes.Attribute:
- return "attribute";
- case Axes.Child:
- return "child";
- case Axes.Descendant:
- return "descendant";
- case Axes.DescendantOrSelf:
- return "descendant-or-self";
- case Axes.Following:
- return "following";
- case Axes.FollowingSibling:
- return "following-sibling";
- case Axes.Namespace:
- return "namespace";
- case Axes.Parent:
- return "parent";
- case Axes.Preceding:
- return "preceding";
- case Axes.PrecedingSibling:
- return "preceding-sibling";
- case Axes.Self:
- return "self";
- default:
- throw new IndexOutOfRangeException ();
+ switch (_axis) {
+ case Axes.Ancestor:
+ return "ancestor";
+ case Axes.AncestorOrSelf:
+ return "ancestor-or-self";
+ case Axes.Attribute:
+ return "attribute";
+ case Axes.Child:
+ return "child";
+ case Axes.Descendant:
+ return "descendant";
+ case Axes.DescendantOrSelf:
+ return "descendant-or-self";
+ case Axes.Following:
+ return "following";
+ case Axes.FollowingSibling:
+ return "following-sibling";
+ case Axes.Namespace:
+ return "namespace";
+ case Axes.Parent:
+ return "parent";
+ case Axes.Preceding:
+ return "preceding";
+ case Axes.PrecedingSibling:
+ return "preceding-sibling";
+ case Axes.Self:
+ return "self";
+ default:
+ throw new IndexOutOfRangeException ();
}
}
public Axes Axis { get { return _axis; }}
- public virtual SimpleIterator Evaluate (BaseIterator iter)
- {
- switch (_axis)
- {
- case Axes.Ancestor:
- return new AncestorIterator (iter);
- case Axes.AncestorOrSelf:
- return new AncestorOrSelfIterator (iter);
- case Axes.Attribute:
- return new AttributeIterator (iter);
- case Axes.Child:
- return new ChildIterator (iter);
- case Axes.Descendant:
- return new DescendantIterator (iter);
- case Axes.DescendantOrSelf:
- return new DescendantOrSelfIterator (iter);
- case Axes.Following:
- return new FollowingIterator (iter);
- case Axes.FollowingSibling:
- return new FollowingSiblingIterator (iter);
- case Axes.Namespace:
- return new NamespaceIterator (iter);
- case Axes.Parent:
- return new ParentIterator (iter);
- case Axes.Preceding:
- return new PrecedingIterator (iter);
- case Axes.PrecedingSibling:
- return new PrecedingSiblingIterator (iter);
- case Axes.Self:
- return new SelfIterator (iter);
- default:
- throw new IndexOutOfRangeException ();
+ public BaseIterator Evaluate (BaseIterator iter)
+ {
+ switch (_axis) {
+ case Axes.Ancestor:
+ return new AncestorIterator (iter);
+ case Axes.AncestorOrSelf:
+ return new AncestorOrSelfIterator (iter);
+ case Axes.Attribute:
+ return new AttributeIterator (iter);
+ case Axes.Child:
+ return new ChildIterator (iter);
+ case Axes.Descendant:
+ return new DescendantIterator (iter);
+ case Axes.DescendantOrSelf:
+ return new DescendantOrSelfIterator (iter);
+ case Axes.Following:
+ return new FollowingIterator (iter);
+ case Axes.FollowingSibling:
+ return new FollowingSiblingIterator (iter);
+ case Axes.Namespace:
+ return new NamespaceIterator (iter);
+ case Axes.Parent:
+ return new ParentIterator (iter);
+ case Axes.Preceding:
+ return new PrecedingIterator (iter);
+ case Axes.PrecedingSibling:
+ return new PrecedingSiblingIterator (iter);
+ case Axes.Self:
+ return new SelfIterator (iter);
+ default:
+ throw new IndexOutOfRangeException ();
}
}
}
public AxisSpecifier Axis { get { return _axis; }}
public override object Evaluate (BaseIterator iter)
{
- SimpleIterator iterAxis = _axis.Evaluate (iter);
+ BaseIterator iterAxis = _axis.Evaluate (iter);
return new AxisIterator (iterAxis, this);
}
case Axes.Ancestor:
case Axes.AncestorOrSelf:
case Axes.Preceding:
+ case Axes.PrecedingSibling:
case Axes.Following:
+ case Axes.FollowingSibling:
return false;
default:
return true;
private static String ToString (XPathNodeType type)
{
- switch (type)
- {
- case XPathNodeType.Comment:
- return "comment";
- case XPathNodeType.Text:
- return "text";
- case XPathNodeType.ProcessingInstruction:
- return "processing-instruction";
- case XPathNodeType.All:
- case XPathNodeType.Attribute:
- case XPathNodeType.Element:
- case XPathNodeType.Namespace:
- return "node";
- default:
- return "node-type [" + type.ToString () + "]";
+ switch (type) {
+ case XPathNodeType.Comment:
+ return "comment";
+ case XPathNodeType.Text:
+ return "text";
+ case XPathNodeType.ProcessingInstruction:
+ return "processing-instruction";
+ case XPathNodeType.All:
+ case XPathNodeType.Attribute:
+ case XPathNodeType.Element:
+ case XPathNodeType.Namespace:
+ return "node";
+ default:
+ return "node-type [" + type.ToString () + "]";
}
}
public override bool Match (NSResolver nsm, XPathNavigator nav)
{
XPathNodeType nodeType = nav.NodeType;
- switch (type)
- {
- case XPathNodeType.All:
- return true;
+ switch (type) {
+ case XPathNodeType.All:
+ return true;
- case XPathNodeType.ProcessingInstruction:
- if (nodeType != XPathNodeType.ProcessingInstruction)
- return false;
- if (_param != null && nav.Name != _param)
- return false;
- return true;
-
+ case XPathNodeType.ProcessingInstruction:
+ if (nodeType != XPathNodeType.ProcessingInstruction)
+ return false;
+ if (_param != null && nav.Name != _param)
+ return false;
+ return true;
+
+ case XPathNodeType.Text:
+ switch (nodeType) {
case XPathNodeType.Text:
- switch (nodeType) {
- case XPathNodeType.Text:
- case XPathNodeType.Whitespace:
- case XPathNodeType.SignificantWhitespace:
- return true;
- default:
- return false;
- }
+ case XPathNodeType.Whitespace:
+ case XPathNodeType.SignificantWhitespace:
+ return true;
default:
- return type == nodeType;
+ return false;
+ }
+ default:
+ return type == nodeType;
}
}
public override object Evaluate (BaseIterator iter)
{
object o = (_expr.Evaluate (iter));
- BaseIterator predBase = o as BaseIterator;
+ XPathNodeIterator xi = o as XPathNodeIterator;
+ BaseIterator predBase = xi as BaseIterator;
+ if (predBase == null && xi != null)
+ predBase = new WrapperIterator (xi, iter.NamespaceManager);
if (predBase != null)
return new ParensIterator (predBase);
else
return new ExprFunctionCall (name, args, ctx);
switch (name.Name) {
- case "last": return new XPathFunctionLast (args);
- case "position": return new XPathFunctionPosition (args);
- case "count": return new XPathFunctionCount (args);
- case "id": return new XPathFunctionId (args);
- case "local-name": return new XPathFunctionLocalName (args);
- case "namespace-uri": return new XPathFunctionNamespaceUri (args);
- case "name": return new XPathFunctionName (args);
- case "string": return new XPathFunctionString (args);
- case "concat": return new XPathFunctionConcat (args);
- case "starts-with": return new XPathFunctionStartsWith (args);
- case "contains": return new XPathFunctionContains (args);
- case "substring-before": return new XPathFunctionSubstringBefore (args);
- case "substring-after": return new XPathFunctionSubstringAfter (args);
- case "substring": return new XPathFunctionSubstring (args);
- case "string-length": return new XPathFunctionStringLength (args);
- case "normalize-space": return new XPathFunctionNormalizeSpace (args);
- case "translate": return new XPathFunctionTranslate (args);
- case "boolean": return new XPathFunctionBoolean (args);
- case "not": return new XPathFunctionNot (args);
- case "true": return new XPathFunctionTrue (args);
- case "false": return new XPathFunctionFalse (args);
- case "lang": return new XPathFunctionLang (args);
- case "number": return new XPathFunctionNumber (args);
- case "sum": return new XPathFunctionSum (args);
- case "floor": return new XPathFunctionFloor (args);
- case "ceiling": return new XPathFunctionCeil (args);
- case "round": return new XPathFunctionRound (args);
+ case "last": return new XPathFunctionLast (args);
+ case "position": return new XPathFunctionPosition (args);
+ case "count": return new XPathFunctionCount (args);
+ case "id": return new XPathFunctionId (args);
+ case "local-name": return new XPathFunctionLocalName (args);
+ case "namespace-uri": return new XPathFunctionNamespaceUri (args);
+ case "name": return new XPathFunctionName (args);
+ case "string": return new XPathFunctionString (args);
+ case "concat": return new XPathFunctionConcat (args);
+ case "starts-with": return new XPathFunctionStartsWith (args);
+ case "contains": return new XPathFunctionContains (args);
+ case "substring-before": return new XPathFunctionSubstringBefore (args);
+ case "substring-after": return new XPathFunctionSubstringAfter (args);
+ case "substring": return new XPathFunctionSubstring (args);
+ case "string-length": return new XPathFunctionStringLength (args);
+ case "normalize-space": return new XPathFunctionNormalizeSpace (args);
+ case "translate": return new XPathFunctionTranslate (args);
+ case "boolean": return new XPathFunctionBoolean (args);
+ case "not": return new XPathFunctionNot (args);
+ case "true": return new XPathFunctionTrue (args);
+ case "false": return new XPathFunctionFalse (args);
+ case "lang": return new XPathFunctionLang (args);
+ case "number": return new XPathFunctionNumber (args);
+ case "sum": return new XPathFunctionSum (args);
+ case "floor": return new XPathFunctionFloor (args);
+ case "ceiling": return new XPathFunctionCeil (args);
+ case "round": return new XPathFunctionRound (args);
}
return new ExprFunctionCall (name, args, ctx);
}
get { return position; }
}
+ internal void SetPosition (int pos)
+ {
+ position = pos;
+ }
+
public override bool MoveNext ()
{
+// FIXME: enable this line once I found the culprit of a breakage in WrapperIterator. And remove it again in the final stage.
+//if (CurrentPosition == 0 && Current != null) throw new Exception (GetType ().FullName);
if (!MoveNextCore ())
return false;
position++;
public abstract bool MoveNextCore ();
+ internal XPathNavigator PeekNext ()
+ {
+ XPathNodeIterator i = Clone ();
+ return i.MoveNext () ? i.Current : null;
+ }
+
public override string ToString ()
{
if (Current != null)
{
protected readonly XPathNavigator _nav;
protected XPathNavigator _current;
+ bool skipfirst;
public SimpleIterator (BaseIterator iter) : base (iter.NamespaceManager)
{
- _nav = iter.Current.Clone ();
+ if (iter.CurrentPosition == 0) {
+ skipfirst = true;
+ iter.MoveNext ();
+ }
+ if (iter.CurrentPosition > 0)
+ _nav = iter.Current.Clone ();
}
protected SimpleIterator (SimpleIterator other, bool clone) : base (other)
{
- _nav = other._nav.Clone ();
+ if (other._nav != null)
+ _nav = clone ? other._nav.Clone () : other._nav;
+ skipfirst = other.skipfirst;
}
public SimpleIterator (XPathNavigator nav, NSResolver nsm) : base (nsm)
{
_nav = nav.Clone ();
}
+ public override bool MoveNext ()
+ {
+ if (skipfirst) {
+ if (_nav == null)
+ return false; // empty
+ skipfirst = false;
+ base.SetPosition (1);
+ return true;
+ } else {
+ return base.MoveNext ();
+ }
+ }
+
public override XPathNavigator Current {
get {
- if (_current == null) // position == 0
- _current = _nav.Clone ();
+ if (CurrentPosition == 0)
+ return null;
+ _current = _nav;
return _current;
}
}
}
public override XPathNavigator Current {
- get { return _nav; }
+ get { return CurrentPosition == 0 ? null : _nav; }
}
}
{
return false;
}
+
+ public override int CurrentPosition {
+ get { return 1; }
+ }
+
+ public override XPathNavigator Current {
+ get { return _nav; }
+ }
}
internal class ParensIterator : BaseIterator
public ParentIterator (BaseIterator iter) : base (iter)
{
canMove = _nav.MoveToParent ();
- _current = _nav;
+ //_current = _nav;
}
private ParentIterator (ParentIterator other, bool dummy) : base (other, true)
{
- _current = _nav;
+ //_current = _nav;
canMove = other.canMove;
}
public ParentIterator (XPathNavigator nav, NSResolver nsm) : base (nav, nsm) {}
}
}
- internal class ChildIterator : SimpleIterator
+ internal class ChildIterator : BaseIterator
{
- public ChildIterator (BaseIterator iter) : base (iter) {}
- private ChildIterator (ChildIterator other) : base (other, true) {}
+ XPathNavigator _nav;
+
+ public ChildIterator (BaseIterator iter) : base (iter.NamespaceManager)
+ {
+ _nav = iter.CurrentPosition == 0 ? iter.PeekNext () : iter.Current;
+ if (_nav != null && _nav.HasChildren)
+ _nav = _nav.Clone ();
+ else
+ _nav = null;
+ }
+ private ChildIterator (ChildIterator other) : base (other)
+ {
+ _nav = other._nav == null ? null : other._nav.Clone ();
+ }
+
public override XPathNodeIterator Clone () { return new ChildIterator (this); }
+
public override bool MoveNextCore ()
{
- bool fSuccess = (CurrentPosition == 0) ? _nav.MoveToFirstChild () : _nav.MoveToNext ();
- if (fSuccess) {
- Current.MoveTo (_nav);
+ if (_nav == null)
+ return false;
+
+ return (CurrentPosition == 0) ? _nav.MoveToFirstChild () : _nav.MoveToNext ();
+ }
+
+ public override XPathNavigator Current {
+ get {
+ if (CurrentPosition == 0)
+ return null;
+ return _nav;
}
- return fSuccess;
}
}
}
if (_nav.MoveToNext ())
{
- Current.MoveTo (_nav);
+// Current.MoveTo (_nav);
return true;
}
return false;
_nav.MoveToFirst ();
if (!_nav.IsSamePosition (startPosition)) {
- Current.MoveTo (_nav);
+// Current.MoveTo (_nav);
return true;
}
} else {
finished = true;
return false;
} else {
- Current.MoveTo (_nav);
+// Current.MoveTo (_nav);
return true;
}
}
if (currentPosition == 0)
return false;
_nav.MoveTo ((XPathNavigator) navigators [--currentPosition]);
- Current.MoveTo (_nav);
+// Current.MoveTo (_nav);
return true;
}
if (startPosition.NodeType != XPathNodeType.Root) {
// First time it returns Root
_nav.MoveToRoot ();
- Current.MoveTo (_nav);
+// Current.MoveTo (_nav);
return true;
}
}
return false;
if (currentPosition-- == 0) {
_nav.MoveTo (startPosition);
- Current.MoveTo (_nav);
+// Current.MoveTo (_nav);
return true; // returns self.
}
_nav.MoveTo ((XPathNavigator) navigators [currentPosition]);
- Current.MoveTo (_nav);
+// Current.MoveTo (_nav);
return true;
}
if (_nav.MoveToFirstChild ())
{
_depth ++;
- Current.MoveTo (_nav);
+// Current.MoveTo (_nav);
return true;
}
while (_depth != 0)
{
if (_nav.MoveToNext ())
{
- Current.MoveTo (_nav);
+// Current.MoveTo (_nav);
return true;
}
if (!_nav.MoveToParent ()) // should NEVER fail!
if (CurrentPosition == 0)
{
// self
- Current.MoveTo (_nav);
+// Current.MoveTo (_nav);
return true;
}
if (_nav.MoveToFirstChild ())
{
_depth ++;
- Current.MoveTo (_nav);
+// Current.MoveTo (_nav);
return true;
}
while (_depth != 0)
{
if (_nav.MoveToNext ())
{
- Current.MoveTo (_nav);
+// Current.MoveTo (_nav);
return true;
}
if (!_nav.MoveToParent ()) // should NEVER fail!
default:
if (_nav.MoveToNext ())
{
- Current.MoveTo (_nav);
+// Current.MoveTo (_nav);
return true;
} else {
while (_nav.MoveToParent ()) {
if (_nav.MoveToNext ()) {
- Current.MoveTo (_nav);
+// Current.MoveTo (_nav);
return true;
}
}
{
if (_nav.MoveToFirstChild ())
{
- Current.MoveTo (_nav);
+// Current.MoveTo (_nav);
return true;
}
do
{
if (_nav.MoveToNext ())
{
- Current.MoveTo (_nav);
+// Current.MoveTo (_nav);
return true;
}
}
finished = true;
return false;
} else {
- Current.MoveTo (_nav);
+// Current.MoveTo (_nav);
return true;
}
}
{
if (_nav.MoveToFirstNamespace ())
{
- Current.MoveTo (_nav);
+// Current.MoveTo (_nav);
return true;
}
}
else if (_nav.MoveToNextNamespace ())
{
- Current.MoveTo (_nav);
+// Current.MoveTo (_nav);
return true;
}
return false;
{
if (_nav.MoveToFirstAttribute ())
{
- Current.MoveTo (_nav);
+// Current.MoveTo (_nav);
return true;
}
}
else if (_nav.MoveToNextAttribute ())
{
- Current.MoveTo (_nav);
+// Current.MoveTo (_nav);
return true;
}
return false;
internal class AxisIterator : BaseIterator
{
- private SimpleIterator _iter;
+ private BaseIterator _iter;
private NodeTest _test;
//string name, ns;
//XPathNodeType matchType;
- public AxisIterator (SimpleIterator iter, NodeTest test) : base (iter.NamespaceManager)
+ public AxisIterator (BaseIterator iter, NodeTest test) : base (iter.NamespaceManager)
{
_iter = iter;
_test = test;
private AxisIterator (AxisIterator other) : base (other)
{
- _iter = (SimpleIterator) other._iter.Clone ();
+ _iter = (BaseIterator) other._iter.Clone ();
_test = other._test;
//name = other.name;
//ns = other.ns;
{
while (_iter.MoveNext ())
{
- if (_test.Match (NamespaceManager, Current))
+ if (_test.Match (NamespaceManager, _iter.Current))
{
return true;
}
}
return false;
}
- public override XPathNavigator Current { get { return _iter.Current; }}
+ public override XPathNavigator Current { get { return CurrentPosition == 0 ? null : _iter.Current; }}
public override bool ReverseAxis {
get { return _iter.ReverseAxis; }
}
}
+ internal class SortedIterator : BaseIterator
+ {
+ ArrayList list;
+
+ public SortedIterator (BaseIterator iter) : base (iter.NamespaceManager)
+ {
+ list = new ArrayList ();
+ while (iter.MoveNext ())
+ list.Add (iter.Current.Clone ());
+
+ // sort
+ if (list.Count == 0)
+ return;
+ XPathNavigator prev = (XPathNavigator) list [0];
+ list.Sort (XPathNavigatorComparer.Instance);
+ for (int i = 1; i < list.Count; i++) {
+ XPathNavigator n = (XPathNavigator) list [i];
+ if (prev.IsSamePosition (n)) {
+ list.RemoveAt (i);
+ i--;
+ }
+ else
+ prev = n;
+ }
+ }
+
+ public SortedIterator (SortedIterator other) : base (other)
+ {
+ this.list = other.list;
+ SetPosition (other.CurrentPosition);
+ }
+
+ public override XPathNodeIterator Clone () { return new SortedIterator (this); }
+
+ public override bool MoveNextCore ()
+ {
+ return CurrentPosition < list.Count;
+ }
+
+ public override XPathNavigator Current {
+ get { return CurrentPosition == 0 ? null : (XPathNavigator) list [CurrentPosition - 1]; }
+ }
+
+ public override int Count {
+ get { return list.Count; }
+ }
+ }
+
+ // NOTE: it is *not* sorted. Do not directly use it without checking sorting requirement.
internal class SlashIterator : BaseIterator
{
private BaseIterator _iterLeft;
private BaseIterator _iterRight;
private NodeSet _expr;
- ArrayList _navStore;
SortedList _iterList;
bool _finished;
BaseIterator _nextIterRight;
- public SlashIterator (BaseIterator iter, NodeSet expr, bool requireSorting) : base (iter.NamespaceManager)
+ public SlashIterator (BaseIterator iter, NodeSet expr) : base (iter.NamespaceManager)
{
_iterLeft = iter;
_expr = expr;
-
- if (requireSorting)
- CollectResults ();
}
private SlashIterator (SlashIterator other) : base (other)
_expr = other._expr;
if (other._iterList != null)
_iterList = (SortedList) other._iterList.Clone ();
- if (other._navStore != null)
- _navStore = (ArrayList) other._navStore.Clone ();
_finished = other._finished;
if (other._nextIterRight != null)
_nextIterRight = (BaseIterator) other._nextIterRight.Clone ();
{
if (_finished)
return false;
- if (_navStore != null) {
- // Which requires sorting::
- if (_navStore.Count < CurrentPosition + 1) {
- _finished = true;
- return false;
- }
- while (_navStore.Count > CurrentPosition + 1) {
- if (((XPathNavigator) _navStore [CurrentPosition + 1]).IsSamePosition (
- (XPathNavigator) _navStore [CurrentPosition]))
- _navStore.RemoveAt (CurrentPosition + 1);
- else
- break;
- }
- return true;
- }
- // Which does not require sorting::
-
if (_iterRight == null) { // First time
if (!_iterLeft.MoveNext ())
return false;
}
}
- private void CollectResults ()
- {
- _navStore = new ArrayList ();
- while (true) {
- while (_iterRight == null || !_iterRight.MoveNext ()) {
- if (!_iterLeft.MoveNext ()) {
- _navStore.Sort (XPathNavigatorComparer.Instance);
- return;
- }
- _iterRight = _expr.EvaluateNodeSet (_iterLeft);
- }
- XPathNavigator nav = _iterRight.Current;
- _navStore.Add (nav.Clone ());
- }
- }
-
public override XPathNavigator Current {
get {
- if (CurrentPosition <= 0) return null;
- if (_navStore != null) {
- return (XPathNavigator) _navStore [CurrentPosition - 1];
- } else {
- return _iterRight.Current;
- }
+ return (CurrentPosition == 0) ? null : _iterRight.Current;
}
}
-
- public override int Count { get { return _navStore == null ? base.Count : _navStore.Count; } }
}
internal class PredicateIterator : BaseIterator
finished = true;
return false;
}
- public override XPathNavigator Current { get { return _iter.Current; }}
+ public override XPathNavigator Current {
+ get { return CurrentPosition == 0 ? null : _iter.Current; }}
public override bool ReverseAxis {
get { return _iter.ReverseAxis; }
}
+public override string ToString () { return _iter.GetType ().FullName; }
}
internal class ListIterator : BaseIterator
}
public override XPathNavigator Current {
get {
- if (_list.Count == 0)
+ if (_list.Count == 0 || CurrentPosition == 0)
return null;
return (XPathNavigator) _list [CurrentPosition - 1];
}
public override XPathNavigator Current
{
- get { return _current; }
+ get { return CurrentPosition > 0 ? _current : null; }
}
}
using System.Collections;
using Mono.Xml.XPath;
+using System.Xml.Xsl;
#if NET_2_0
using NSResolver = System.Xml.IXmlNamespaceResolver;
#endif
internal static XPathExpression Compile (string xpath,
- NSResolver nsmgr, System.Xml.Xsl.IStaticXsltContext ctx)
+ NSResolver nsmgr, IStaticXsltContext ctx)
{
- XPathParser parser = new XPathParser (ctx);
- XPathExpression x = new CompiledExpression (
- xpath, parser.Compile (xpath));
+ XPathExpression x = ExpressionCache.Get (xpath, ctx);
+ if (x == null) {
+ XPathParser parser = new XPathParser (ctx);
+ x = new CompiledExpression (xpath, parser.Compile (xpath));
+ ExpressionCache.Set (xpath, ctx, x);
+ }
x.SetContext (nsmgr);
return x;
}
//
using System;
-#if NET_2_0
using System.Collections;
+#if NET_2_0
using System.Collections.Generic;
using System.Diagnostics;
using System.Text;
public abstract class XPathNavigator : ICloneable
#endif
{
+ class EnumerableIterator : XPathNodeIterator
+ {
+ IEnumerable source;
+ IEnumerator e;
+ int pos;
+
+ public EnumerableIterator (IEnumerable source, int pos)
+ {
+ this.source = source;
+ for (int i = 0; i < pos; i++)
+ MoveNext ();
+ }
+
+ public override XPathNodeIterator Clone ()
+ {
+ return new EnumerableIterator (source, pos);
+ }
+
+ public override bool MoveNext ()
+ {
+ if (e == null)
+ e = source.GetEnumerator ();
+ if (!e.MoveNext ())
+ return false;
+ pos++;
+ return true;
+ }
+
+ public override int CurrentPosition {
+ get { return pos; }
+ }
+
+ public override XPathNavigator Current {
+ get { return pos == 0 ? null : (XPathNavigator) e.Current; }
+ }
+ }
+
#region Static members
#if NET_2_0
public static IEqualityComparer NavigatorComparer {
{
return Evaluate (expr, context, null);
}
-
- internal virtual object Evaluate (XPathExpression expr, XPathNodeIterator context, NSResolver ctx)
+
+ BaseIterator ToBaseIterator (XPathNodeIterator iter, NSResolver ctx)
+ {
+ BaseIterator i = iter as BaseIterator;
+ if (i == null)
+ i = new WrapperIterator (iter, ctx);
+ return i;
+ }
+
+ object Evaluate (XPathExpression expr, XPathNodeIterator context, NSResolver ctx)
{
CompiledExpression cexpr = (CompiledExpression) expr;
if (ctx == null)
if (context == null)
context = new NullIterator (this, ctx);
- BaseIterator iterContext = (BaseIterator) context;
+ BaseIterator iterContext = ToBaseIterator (context, ctx);
iterContext.NamespaceManager = ctx;
return cexpr.Evaluate (iterContext);
}
if (context == null)
context = new NullIterator (this, cexpr.NamespaceManager);
- BaseIterator iterContext = (BaseIterator) context;
+ BaseIterator iterContext = ToBaseIterator (context, ctx);
iterContext.NamespaceManager = ctx;
return cexpr.EvaluateNodeSet (iterContext);
}
if (context == null)
context = new NullIterator (this, cexpr.NamespaceManager);
- BaseIterator iterContext = (BaseIterator) context;
- iterContext.NamespaceManager = ctx;
+ BaseIterator iterContext = ToBaseIterator (context, ctx);
return cexpr.EvaluateString (iterContext);
}
if (context == null)
context = new NullIterator (this, cexpr.NamespaceManager);
- BaseIterator iterContext = (BaseIterator) context;
+ BaseIterator iterContext = ToBaseIterator (context, ctx);
iterContext.NamespaceManager = ctx;
return cexpr.EvaluateNumber (iterContext);
}
if (context == null)
context = new NullIterator (this, cexpr.NamespaceManager);
- BaseIterator iterContext = (BaseIterator) context;
+ BaseIterator iterContext = ToBaseIterator (context, ctx);
iterContext.NamespaceManager = ctx;
return cexpr.EvaluateBoolean (iterContext);
}
return Select (expr, null);
}
- internal virtual XPathNodeIterator Select (XPathExpression expr, NSResolver ctx)
+ internal XPathNodeIterator Select (XPathExpression expr, NSResolver ctx)
{
CompiledExpression cexpr = (CompiledExpression) expr;
if (ctx == null)
return SelectTest (new NodeNameTest (axis, qname, true));
}
+ static IEnumerable EnumerateChildren (XPathNavigator n, XPathNodeType type)
+ {
+ if (!n.MoveToFirstChild ())
+ yield break;
+ n.MoveToParent ();
+ XPathNavigator nav = n.Clone ();
+ nav.MoveToFirstChild ();
+ XPathNavigator nav2 = null;
+ do {
+ if (type == XPathNodeType.All || nav.NodeType == type) {
+ if (nav2 == null)
+ nav2 = nav.Clone ();
+ else
+ nav2.MoveTo (nav);
+ yield return nav2;
+ }
+ } while (nav.MoveToNext ());
+ }
+
public virtual XPathNodeIterator SelectChildren (XPathNodeType type)
{
+#if false
return SelectTest (new NodeTypeTest (Axes.Child, type));
+#else
+ return new WrapperIterator (new EnumerableIterator (EnumerateChildren (this, type), 0), null);
+ // FIXME: make it work i.e. remove dependency on BaseIterator
+// return new EnumerableIterator (EnumerateChildren (this, type), 0);
+#endif
+ }
+
+ static IEnumerable EnumerateChildren (XPathNavigator n, string name, string ns)
+ {
+ if (!n.MoveToFirstChild ())
+ yield break;
+ n.MoveToParent ();
+ XPathNavigator nav = n.Clone ();
+ nav.MoveToFirstChild ();
+ XPathNavigator nav2 = nav.Clone ();
+ do {
+ if (nav.LocalName == name && nav.NamespaceURI == ns) {
+ nav2.MoveTo (nav);
+ yield return nav2;
+ }
+ } while (nav.MoveToNext ());
}
public virtual XPathNodeIterator SelectChildren (string name, string namespaceURI)
if (namespaceURI == null)
throw new ArgumentNullException ("namespaceURI");
+#if false
Axes axis = Axes.Child;
XmlQualifiedName qname = new XmlQualifiedName (name, namespaceURI);
return SelectTest (new NodeNameTest (axis, qname, true));
+#else
+ return new WrapperIterator (new EnumerableIterator (EnumerateChildren (this, name, namespaceURI), 0), null);
+#endif
}
public virtual XPathNodeIterator SelectDescendants (XPathNodeType type, bool matchSelf)
* XmlTextReader.cs : simply call ClearValueBuffer() on each Read().
+2008-10-02 Atsushi Enomoto <atsushi@ximian.com>
+
+ * XmlDocumentNavigator.cs : added some overriden methods (to be
+ implemented).
+
2008-09-24 Atsushi Enomoto <atsushi@ximian.com>
* XmlDocument.cs : it returns non-null Schemas by default (and
if (ec != null)
return ec;
}
- return c;
+ else
+ return c;
}
return null;
default:
if (ec != null)
return ec;
}
- return c;
+ else
+ return c;
}
return null;
default:
return null;
}
+#if NET_2_0
+ public
+#else
+ internal
+#endif
+ override string LookupNamespace (string prefix)
+ {
+ // FIXME: optimize
+ return base.LookupNamespace (prefix);
+ }
+
+#if NET_2_0
+ public
+#else
+ internal
+#endif
+ override string LookupPrefix (string namespaceUri)
+ {
+ // FIXME: optimize
+ return base.LookupPrefix (namespaceUri);
+ }
+
+#if NET_2_0
+ public
+#else
+ internal
+#endif
+ override bool MoveToChild (XPathNodeType type)
+ {
+ // FIXME: optimize
+ return base.MoveToChild (type);
+ }
+
+#if NET_2_0
+ public
+#else
+ internal
+#endif
+ override bool MoveToChild (string localName, string namespaceURI)
+ {
+ // FIXME: optimize
+ return base.MoveToChild (localName, namespaceURI);
+ }
+
+#if NET_2_0
+ public
+#else
+ internal
+#endif
+ override bool MoveToNext (string localName, string namespaceURI)
+ {
+ // FIXME: optimize
+ return base.MoveToNext (localName, namespaceURI);
+ }
+
+#if NET_2_0
+ public
+#else
+ internal
+#endif
+ override bool MoveToNext (XPathNodeType type)
+ {
+ // FIXME: optimize
+ return base.MoveToNext (type);
+ }
+
+#if NET_2_0
+ public
+#else
+ internal
+#endif
+ override bool MoveToFollowing (string localName,
+ string namespaceURI, XPathNavigator end)
+ {
+ // FIXME: optimize
+ return base.MoveToFollowing (localName, namespaceURI, end);
+ }
+
+#if NET_2_0
+ public
+#else
+ internal
+#endif
+ override bool MoveToFollowing (XPathNodeType type,
+ XPathNavigator end)
+ {
+ // FIXME: optimize
+ return base.MoveToFollowing (type, end);
+ }
#endregion
}
}
+2008-10-02 Atsushi Enomoto <atsushi@ximian.com>
+
+ * XPathNavigatorEvaluateTests.cs : corrected couple of misconception
+ in the tests.
+
2008-04-02 Atsushi Enomoto <atsushi@ximian.com>
* XPathEditableNavigatorTests.cs : added test for bug #376210.
// Testing Core Funcetion Library functions defined at: http://www.w3.org/TR/xpath#corelib
[Test]
-#if NET_2_0
+#if !NET_2_0
// .NET 2.0 is fixed for last() to return 1 for the
- // initial context position. We should follow the fix.
- [Category ("NotWorking")]
+ // initial context position. Someone thinks we should follow
+ // the fix, but in reality we should just discard this
+ // pointless test. The positional value under those conditions
+ // does not make any sense.
[Category ("NotDotNet")]
#endif
public void CoreFunctionNodeSetLast ()
{
expression = navigator.Compile("last()");
iterator = navigator.Select("/foo");
- AssertEquals ("0", navigator.Evaluate ("last()").ToString());
- AssertEquals ("0", navigator.Evaluate (expression, null).ToString ());
+ AssertEquals ("1", navigator.Evaluate ("last()").ToString());
+ AssertEquals ("1", navigator.Evaluate (expression, null).ToString ());
AssertEquals ("1", navigator.Evaluate (expression, iterator).ToString ());
iterator = navigator.Select("/foo/*");
AssertEquals ("4", navigator.Evaluate (expression, iterator).ToString ());
}
[Test]
-#if NET_2_0
+#if !NET_2_0
// .NET 2.0 is fixed for position() to return 1 for the
- // initial context position. We should follow the fix.
- [Category ("NotWorking")]
+ // initial context position. Someone thinks we should follow
+ // the fix, but in reality we should just discard this
+ // pointless test. The positional value under those conditions
+ // does not make any sense.
+// [Category ("NotWorking")]
[Category ("NotDotNet")]
#endif
public void CoreFunctionNodeSetPosition ()
{
expression = navigator.Compile("position()");
iterator = navigator.Select("/foo");
- AssertEquals ("#1", "0", navigator.Evaluate ("position()").ToString ());
- AssertEquals ("#2", "0", navigator.Evaluate (expression, null).ToString ());
+ AssertEquals ("#1", "1", navigator.Evaluate ("position()").ToString ());
+ AssertEquals ("#2", "1", navigator.Evaluate (expression, null).ToString ());
AssertEquals ("#3", "0", navigator.Evaluate (expression, iterator).ToString ());
iterator = navigator.Select("/foo/*");
AssertEquals ("#4", "0", navigator.Evaluate (expression, iterator).ToString ());
+2008-10-02 Atsushi Enomoto <atsushi@ximian.com>
+
+ * XslTransformTests.cs : removed extra NotDotNet.
+
2008-06-04 Atsushi Enomoto <atsushi@ximian.com>
* XslTransformTests.cs : added test for bug #378239.
[Test] // reverse case of #349375
[Category ("NotWorking")]
+// [Category ("NotDotNet")]
public void PreserveWhitespace2 ()
{
XslCompiledTransform xslt = new XslCompiledTransform ();
</p>
</l0>
</root>")), null, sw);
- Assert.AreEqual (@"<y><t yes-one-node="""">1</t><t not-node=""""></t></y>", sw.ToString ());
+// Assert.AreEqual (@"<y><t yes-one-node="""">1</t><t not-node=""""></t></y>", sw.ToString ());
+ Assert.AreEqual ("\r\n \r\n <y><t yes-one-node=\"\">1</t><t not-node=\"\"></t></y>\r\n \r\n", sw.ToString ());
}
[Test]
+2008-10-02 Atsushi Enomoto <atsushi@ximian.com>
+
+ * Makefile : fixed couple of obsolete settings.
+
2008-06-04 Atsushi Enomoto <atsushi@ximian.com>
* XsltTestUtils.cs : fixed incorrect use of EnvOptions.WhitespaceStyle
ifeq ($(PROFILE), net_2_0)
nunit_MONO_PATH="../../../../../class/lib/net_2_0"
- CSCOMPILE=gmcs
+ CSCOMPILE=MONO_PATH=../../../../../class/lib/net_2_0 ../../../../../../mono/runtime/mono-wrapper ../../../../../class/lib/net_2_0/gmcs.exe
else
nunit_MONO_PATH="../../../../../class/lib/net_1_1"
CSCOMPILE=mcs
FIXED_CATALOG = testsuite/TESTS/catalog-fixed.xml
mono_wrapper_PATH="../../../../../../mono/runtime/mono-wrapper"
-NUNIT_CONSOLE=$(mono_wrapper_PATH) --debug nunit-console.exe
+NUNIT_CONSOLE=$(mono_wrapper_PATH) --debug ./nunit-console.exe
FIXTURE=MonoTests.oasis_xslt.SuiteBuilder
CLEAN_NUNIT_FLAGS=/fixture:$(FIXTURE) /xml=TestResult.xml /include=Clean
REFERENCE_RESULTS_NAME=results
endif
REFERENCE_RESULTS_ARCHIVE=xslt-reference-$(REFERENCE_RESULTS_NAME).tar.gz
-REFERENCE_RESULTS_URL=http://svn.myrealbox.com/source/trunk/release/test-ext/xslt-standalone/$(REFERENCE_RESULTS_ARCHIVE)
+REFERENCE_RESULTS_URL=http://anonsvn.mono-project.com/source/trunk/release/test-ext/xslt-standalone/$(REFERENCE_RESULTS_ARCHIVE)
REFERENCE_RESULTS=$(REFERENCE_RESULTS_NAME)/timestamp
test : $(TEST_PROG) $(FIXED_CATALOG) $(REFERENCE_RESULTS)
touch $@
$(REFERENCE_RESULTS_ARCHIVE) :
- wget $(REFERENCE_RESULTS_URL)
+ wget -O $(REFERENCE_RESULTS_ARCHIVE) $(REFERENCE_RESULTS_URL)
projects / mono.git / commitdiff