public ExprNodeIterator(XPath2Context context, AbstractNode node, object[] dataPool, XPath2NodeIterator baseIter)
{
this.context = context;
this.node = node;
this.dataPool = dataPool;
this.baseIter = baseIter;
}
protected override XPathItem NextItem()
{
while (true)
{
if (childIter != null)
{
if (childIter.MoveNext())
{
return(childIter.Current);
}
else
{
childIter = null;
}
}
if (index == nodes.Length)
{
return(null);
}
object res = nodes[index++].Execute(provider, dataPool);
if (res != Undefined.Value)
{
childIter = res as XPath2NodeIterator;
if (childIter == null)
{
XPathItem item = res as XPathItem;
if (item == null)
{
return(new XPath2Item(res));
}
return(item);
}
}
}
}
protected override XPathItem NextItem()
{
while (true)
{
if (childIter != null)
{
if (childIter.MoveNext())
{
return(childIter.Current);
}
else
{
childIter = null;
}
}
if (!iter.MoveNext())
{
return(null);
}
object res;
if (owner.MoveNext(provider, dataPool, iter.Current, out res))
{
childIter = res as XPath2NodeIterator;
if (childIter == null)
{
XPathItem item = res as XPathItem;
if (item != null)
{
return(item);
}
return(new XPath2Item(res));
}
}
}
}
public ForIterator(ForNode owner, IContextProvider provider, object[] dataPool, XPath2NodeIterator baseIter)
{
this.owner = owner;
this.provider = provider;
this.dataPool = dataPool;
this.baseIter = baseIter;
}
public override object Execute(IContextProvider provider, object[] dataPool)
{
bool orderedSet = _isOrderedSet;
bool special = provider != null &&
provider.Context.GetType().Name == "XPathDocumentNavigator";
XPath2NodeIterator tail;
if (_path[0].type == XPath2ExprType.Expr)
{
tail = XPath2NodeIterator.Create(_path[0].node.Execute(provider, dataPool));
if (!(_path[0].node is OrderedBinaryOperatorNode))
{
orderedSet = orderedSet & tail.IsSingleIterator;
}
}
else
{
tail = _path[0].Create(Context, dataPool,
XPath2NodeIterator.Create(CoreFuncs.ContextNode(provider)), special);
}
for (int k = 1; k < _path.Length; k++)
{
tail = _path[k].Create(Context, dataPool, tail, special);
}
if (!orderedSet)
{
return(new DocumentOrderNodeIterator(tail));
}
return(tail);
}
private ChildOverDescendantsNodeIterator(ChildOverDescendantsNodeIterator src)
{
context = src.context;
nodeTest = src.nodeTest;
iter = src.iter.Clone();
lastTest = src.lastTest;
kind = src.kind;
}
protected void AssignFrom(AxisNodeIterator src)
{
context = src.context;
typeTest = src.typeTest;
nameTest = src.nameTest;
matchSelf = src.matchSelf;
iter = src.iter.Clone();
}
private ChildOverDescendantsNodeIterator(ChildOverDescendantsNodeIterator src)
{
_context = src._context;
_nodeTest = src._nodeTest;
_iterator = src._iterator.Clone();
_lastTest = src._lastTest;
_kind = src._kind;
}
public override object Execute(IContextProvider provider, object[] dataPool)
{
XPath2NodeIterator iter = XPath2NodeIterator.Create(this[0].Execute(provider, dataPool));
for (int k = 1; k < Count; k++)
{
iter = new NodeIterator(CreateEnumerator(dataPool, this[k], iter));
}
return(iter);
}
public SpecialDescendantNodeIterator(XPath2Context context, object nodeTest, bool matchSelf,
XPath2NodeIterator iter)
: base(context, nodeTest, matchSelf, iter)
{
kind = XPathNodeType.All;
if (nameTest != null ||
(typeTest != null && typeTest.GetNodeKind() == XPathNodeType.Element))
{
kind = XPathNodeType.Element;
}
}
public ChildOverDescendantsNodeIterator(XPath2Context context, NodeTest[] nodeTest, XPath2NodeIterator iterator)
{
_context = context;
_nodeTest = nodeTest;
_iterator = iterator;
_lastTest = nodeTest[nodeTest.Length - 1];
_kind = XPathNodeType.All;
if (_lastTest.NameTest != null || (_lastTest.TypeTest != null && _lastTest.TypeTest.GetNodeKind() == XPathNodeType.Element))
{
_kind = XPathNodeType.Element;
}
}
public ChildOverDescendantsNodeIterator(XPath2Context context, NodeTest[] nodeTest, XPath2NodeIterator iter)
{
this.context = context;
this.nodeTest = nodeTest;
this.iter = iter;
lastTest = nodeTest[nodeTest.Length - 1];
kind = XPathNodeType.All;
if (lastTest.nameTest != null ||
(lastTest.typeTest != null && lastTest.typeTest.GetNodeKind() == XPathNodeType.Element))
{
kind = XPathNodeType.Element;
}
}
public AxisNodeIterator(XPath2Context context, object nodeTest, bool matchSelf, XPath2NodeIterator iter)
{
this.context = context;
if (nodeTest is XmlQualifiedNameTest)
{
nameTest = (XmlQualifiedNameTest)nodeTest;
}
else if (nodeTest is SequenceType && nodeTest != SequenceType.Node)
{
typeTest = (SequenceType)nodeTest;
}
this.matchSelf = matchSelf;
this.iter = iter;
}
private void TraceIter(XPath2NodeIterator iter)
{
iter = iter.Clone();
foreach (XPathItem item in iter)
{
if (item.IsNode)
{
Trace.WriteLine(((XPathNavigator)item).OuterXml);
}
else
{
Trace.WriteLine(item.Value);
}
}
}
public FollowingNodeIterator(XPath2Context context, object nodeTest, XPath2NodeIterator iter)
: base(context, nodeTest, false, iter)
{
if (typeTest == null)
{
if (nameTest == null)
{
kind = XPathNodeType.All;
}
else
{
kind = XPathNodeType.Element;
}
}
else
{
kind = typeTest.GetNodeKind();
}
}
protected override XPathItem NextItem()
{
while (true)
{
if (iter == null)
{
if (!baseIter.MoveNext())
{
return(null);
}
sequentialPosition = 0;
iter = XPath2NodeIterator.Create(node.Execute(new NodeProvider(baseIter.Current), dataPool));
}
if (iter.MoveNext())
{
sequentialPosition++;
return(iter.Current);
}
iter = null;
}
}
public DocumentOrderNodeIterator(XPath2NodeIterator baseIter)
{
bool?isNode = null;
itemSet = new ItemSet();
while (baseIter.MoveNext())
{
if (!isNode.HasValue)
{
isNode = baseIter.Current.IsNode;
}
else if (baseIter.Current.IsNode != isNode)
{
throw new XPath2Exception("XPTY0018", Resources.XPTY0018, baseIter.Current.Value);
}
itemSet.Add(baseIter.Current.Clone());
}
if (isNode.HasValue && isNode.Value)
{
itemSet.Sort();
}
}
private void runCurrentToolStripMenuItem_Click(object sender, EventArgs e)
{
if (dataGridView1.CurrentRow == null)
{
return;
}
richTextBox1.Clear();
XmlElement testCase = (XmlElement)dataGridView1.CurrentRow.Cells[5].Value;
try
{
object res = PrepareXPath(_out, testCase).Evalute();
if (res != null)
{
if (res is XPath2NodeIterator)
{
XPath2NodeIterator iter = (XPath2NodeIterator)res;
while (iter.MoveNext())
{
_out.WriteLine();
_out.WriteItem(iter.Current);
}
}
else
{
_out.WriteLine();
_out.WriteItem(res);
}
}
}
catch (Exception ex)
{
_out.WriteLine();
_out.WriteLine(ex);
}
}
public AncestorNodeIterator(XPath2Context context, object nodeTest, bool matchSelf, XPath2NodeIterator iter)
: base(context, nodeTest, matchSelf, iter)
{
}
private IEnumerable <XPathItem> CreateEnumerator(object[] dataPool, AbstractNode expr,
XPath2NodeIterator baseIter)
{
XPath2NodeIterator iter = baseIter.Clone();
ValueNode numexpr = expr as ValueNode;
if (numexpr != null && numexpr.Content is Integer)
{
Integer pos = (Integer)numexpr.Content;
foreach (XPathItem item in iter)
{
if (pos == 1)
{
yield return(item);
break;
}
else
{
pos--;
}
}
}
else
{
ContextProvider provider = new ContextProvider(iter);
object res = Undefined.Value;
while (iter.MoveNext())
{
if (m_contextSensitive || res == Undefined.Value)
{
res = expr.Execute(provider, dataPool);
}
if (res == Undefined.Value)
{
if (!m_contextSensitive)
{
break;
}
continue;
}
XPath2NodeIterator iter2 = res as XPath2NodeIterator;
XPathItem item;
if (iter2 != null)
{
iter2 = iter2.Clone();
if (!iter2.MoveNext())
{
continue;
}
item = iter2.Current.Clone();
if (!item.IsNode && iter2.MoveNext())
{
throw new XPath2Exception("FORG0006", Resources.FORG0006, "fn:boolean()",
new SequenceType(XmlTypeCode.AnyAtomicType, XmlTypeCardinality.OneOrMore));
}
}
else
{
item = res as XPathItem;
if (item == null)
{
item = new XPath2Item(res);
}
}
if (item.IsNode)
{
yield return(iter.Current);
}
else
{
if (ValueProxy.IsNumeric(item.ValueType))
{
if (CoreFuncs.OperatorEq(iter.CurrentPosition + 1, item.GetTypedValue()) == CoreFuncs.True)
{
yield return(iter.Current);
if (!m_contextSensitive)
{
break;
}
}
}
else if (CoreFuncs.GetBooleanValue(item))
{
yield return(iter.Current);
}
}
}
}
}
protected override void Init()
{
iter = baseIter.Clone();
}
public PositionFilterNodeIterator(int pos, XPath2NodeIterator baseIter)
{
iter = baseIter;
position = pos;
}
public override object Execute(IContextProvider provider, object[] dataPool)
{
return(new ForIterator(this, provider, dataPool,
XPath2NodeIterator.Create(this[0].Execute(provider, dataPool))));
}
public ParentNodeIterator(XPath2Context context, object nodeTest, XPath2NodeIterator iter)
: base(context, nodeTest, false, iter)
{
}
public FollowingSiblingNodeIterator(XPath2Context context, object nodeTest, XPath2NodeIterator iter)
: base(context, nodeTest, false, iter)
{
}
private bool CompareResult(XmlNode testCase, string sourceFile, object value, bool xmlCompare)
{
string id = ((XmlElement)testCase).GetAttribute("name");
bool isSingle = false;
bool isExcpt = (id == "fn-union-node-args-005") ||
(id == "fn-union-node-args-006") || (id == "fn-union-node-args-007") ||
(id == "fn-union-node-args-009") || (id == "fn-union-node-args-010") ||
(id == "fn-union-node-args-011");
if (id == "ReturnExpr010")
{
xmlCompare = true;
}
if (id != "CondExpr012" && id != "NodeTest006")
{
if (value is XPathItem)
{
isSingle = true;
}
else if (value is XPath2NodeIterator)
{
XPath2NodeIterator iter = (XPath2NodeIterator)value;
isSingle = iter.IsSingleIterator;
}
}
XmlDocument doc1 = new XmlDocument(_nameTable);
if (xmlCompare)
{
doc1.Load(sourceFile);
}
else
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("<?xml version='1.0'?>");
sb.Append("<root>");
TextReader textReader = new StreamReader(sourceFile, true);
sb.Append(textReader.ReadToEnd());
textReader.Close();
sb.Append("</root>");
doc1.LoadXml(sb.ToString());
}
MemoryStream ms = new MemoryStream();
XmlWriter writer = new XmlTextWriter(ms, Encoding.UTF8);
if (!(xmlCompare && isSingle || isExcpt))
{
writer.WriteStartDocument();
writer.WriteStartElement(doc1.DocumentElement.Name, "");
}
if (value is XPath2NodeIterator)
{
bool string_flag = false;
foreach (XPathItem item in (XPath2NodeIterator)value)
{
if (item.IsNode)
{
XPathNavigator nav = (XPathNavigator)item;
if (nav.NodeType == XPathNodeType.Attribute)
{
writer.WriteStartAttribute(nav.Prefix, nav.LocalName, nav.NamespaceURI);
writer.WriteString(nav.Value);
writer.WriteEndAttribute();
}
else
{
writer.WriteNode(nav, false);
}
string_flag = false;
}
else
{
if (string_flag)
{
writer.WriteString(" ");
}
writer.WriteString(item.Value);
string_flag = true;
}
}
}
else
if (value is XPathItem)
{
XPathItem item = (XPathItem)value;
if (item.IsNode)
{
writer.WriteNode((XPathNavigator)item, false);
}
else
{
writer.WriteString(item.Value);
}
}
else
{
if (value != Undefined.Value)
{
writer.WriteString(XPath2Convert.ToString(value));
}
}
if (!(xmlCompare && isSingle || isExcpt))
{
writer.WriteEndElement();
}
writer.Flush();
ms.Position = 0;
XmlDocument doc2 = new XmlDocument(_nameTable);
doc2.Load(ms);
writer.Close();
TreeComparer comparer = new TreeComparer();
comparer.IgnoreWhitespace = true;
bool res = comparer.DeepEqual(doc1.CreateNavigator(), doc2.CreateNavigator());
return(res);
}
private bool PerformTest(TextWriter tw, XmlElement testCase, bool batchTest)
{
try
{
PreparedXPath preparedXPath;
XPath2ResultType expectedType;
try
{
preparedXPath = PrepareXPath(tw, testCase);
expectedType = preparedXPath.GetResultType();
}
catch (XPath2Exception)
{
if (testCase.GetAttribute("scenario") == "parse-error" ||
testCase.GetAttribute("scenario") == "runtime-error" ||
testCase.SelectSingleNode("ts:expected-error", _nsmgr) != null)
{
return(true);
}
throw;
}
object res;
try
{
res = preparedXPath.Evalute();
if (res != Undefined.Value &&
preparedXPath.GetResultType() != expectedType)
{
if (batchTest)
{
_out.Write("{0}: ", testCase.GetAttribute("name"));
}
_out.WriteLine("Expected type '{0}' differs the actual type '{1}'",
expectedType, preparedXPath.GetResultType());
}
}
catch (XPath2Exception)
{
if (testCase.GetAttribute("scenario") == "parse-error" ||
testCase.GetAttribute("scenario") == "runtime-error" ||
testCase.SelectSingleNode("ts:expected-error", _nsmgr) != null)
{
return(true);
}
throw;
}
try
{
if (testCase.GetAttribute("scenario") == "standard")
{
foreach (XmlElement outputFile in testCase.SelectNodes("ts:output-file", _nsmgr))
{
string compare = outputFile.GetAttribute("compare");
if (compare == "Text" || compare == "Fragment")
{
if (CompareResult(testCase, GetResultPath(testCase, outputFile.InnerText), res, false))
{
return(true);
}
}
else if (compare == "XML")
{
if (CompareResult(testCase, GetResultPath(testCase, outputFile.InnerText), res, true))
{
return(true);
}
}
else if (compare == "Inspect")
{
_out.WriteLine("{0}: Inspection needed.", testCase.GetAttribute("name"));
return(true);
}
else if (compare == "Ignore")
{
continue;
}
else
{
throw new InvalidOperationException();
}
}
return(false);
}
else if (testCase.GetAttribute("scenario") == "runtime-error")
{
if (res is XPath2NodeIterator)
{
XPath2NodeIterator iter = (XPath2NodeIterator)res;
while (iter.MoveNext())
{
;
}
}
return(false);
}
return(true);
}
catch (XPath2Exception)
{
if (testCase.GetAttribute("scenario") == "runtime-error" ||
testCase.SelectSingleNode("ts:expected-error", _nsmgr) != null)
{
return(true);
}
throw;
}
}
catch (Exception ex)
{
_out.WriteLine();
_out.WriteLine(ex);
return(false);
}
}
public override void ResetSequentialPosition()
{
iter = null;
}
public XPath2NodeIterator Create(XPath2Context context, object[] dataPool, XPath2NodeIterator baseIter, bool special)
{
switch (type)
{
case XPath2ExprType.Attribute:
return(new AttributeNodeIterator(context, nodeTest, baseIter));
case XPath2ExprType.Child:
{
if (special && nodeTest != SequenceType.Node)
{
return(new SpecialChildNodeIterator(context, nodeTest, baseIter));
}
return(new ChildNodeIterator(context, nodeTest, baseIter));
}
case XPath2ExprType.Descendant:
{
if (special && nodeTest != SequenceType.Node)
{
return(new SpecialDescendantNodeIterator(context, nodeTest, false, baseIter));
}
return(new DescendantNodeIterator(context, nodeTest, false, baseIter));
}
case XPath2ExprType.DescendantOrSelf:
{
if (special && nodeTest != SequenceType.Node)
{
return(new SpecialDescendantNodeIterator(context, nodeTest, true, baseIter));
}
return(new DescendantNodeIterator(context, nodeTest, true, baseIter));
}
case XPath2ExprType.Ancestor:
return(new AncestorNodeIterator(context, nodeTest, false, baseIter));
case XPath2ExprType.AncestorOrSelf:
return(new AncestorNodeIterator(context, nodeTest, true, baseIter));
case XPath2ExprType.Following:
return(new FollowingNodeIterator(context, nodeTest, baseIter));
case XPath2ExprType.FollowingSibling:
return(new FollowingSiblingNodeIterator(context, nodeTest, baseIter));
case XPath2ExprType.Parent:
return(new ParentNodeIterator(context, nodeTest, baseIter));
case XPath2ExprType.Preceding:
return(new PrecedingNodeIterator(context, nodeTest, baseIter));
case XPath2ExprType.PrecedingSibling:
return(new PrecedingSiblingNodeIterator(context, nodeTest, baseIter));
case XPath2ExprType.Namespace:
return(new NamespaceNodeIterator(context, nodeTest, baseIter));
case XPath2ExprType.Self:
return(new SelfNodeIterator(context, nodeTest, baseIter));
case XPath2ExprType.Expr:
return(new ExprNodeIterator(context, node, dataPool, baseIter));
case XPath2ExprType.PositionFilter:
return(new PositionFilterNodeIterator(Convert.ToInt32(nodeTest), baseIter));
case XPath2ExprType.ChildOverDescendants:
return(new ChildOverDescendantsNodeIterator(context,
(ChildOverDescendantsNodeIterator.NodeTest[])nodeTest, baseIter));
default:
return(null);
}
}
public SequentialAxisNodeIterator(XPath2Context context, object nodeTest, bool matchSelf, XPath2NodeIterator iter)
: base(context, nodeTest, matchSelf, iter)
{
}
