internal override void InvokeInternal(ProcessingContext context, int argCount)
{
int iterationCount = context.IterationCount;
context.PushSequenceFrame();
if (iterationCount > 0)
{
NodeSequence seq = context.CreateSequence();
seq.StartNodeset();
SeekableXPathNavigator contextNode = context.Processor.ContextNode;
long currentPosition = contextNode.CurrentPosition;
if (XPathMessageFunction.MoveToAddressingHeader(contextNode, "ReplyTo"))
{
seq.Add(contextNode);
}
seq.StopNodeset();
context.PushSequence(seq);
for (int i = 1; i < iterationCount; i++)
{
seq.refCount++;
context.PushSequence(seq);
}
contextNode.CurrentPosition = currentPosition;
}
}
internal static void IterateAndPushSequences(ProcessingContext context)
{
StackFrame topSequenceArg = context.TopSequenceArg;
Value[] sequences = context.Sequences;
context.PushFrame();
while (topSequenceArg.basePtr <= topSequenceArg.endPtr)
{
NodeSequence sequence = sequences[topSequenceArg.basePtr++].Sequence;
if (sequence.Count == 0)
{
context.PushSequence(NodeSequence.Empty);
}
else
{
for (int i = 0; i < sequence.Count; i++)
{
NodeSequence sequence2 = context.CreateSequence();
sequence2.StartNodeset();
sequence2.Add(ref sequence.Items[i]);
sequence2.StopNodeset();
context.Push(sequence2);
}
}
}
}
internal static void IterateAndPushSequences(ProcessingContext context)
{
StackFrame sequences = context.TopSequenceArg;
Value[] sequenceBuffer = context.Sequences;
context.PushFrame();
while (sequences.basePtr <= sequences.endPtr)
{
NodeSequence sourceSeq = sequenceBuffer[sequences.basePtr++].Sequence;
int count = sourceSeq.Count;
if (count == 0)
{
context.PushSequence(NodeSequence.Empty);
}
else
{
for (int item = 0; item < sourceSeq.Count; ++item)
{
NodeSequence newSequence = context.CreateSequence();
newSequence.StartNodeset();
newSequence.Add(ref sourceSeq.Items[item]);
newSequence.StopNodeset();
context.Push(newSequence);
}
}
}
}
internal override Opcode Eval(ProcessingContext context)
{
StackFrame topSequenceArg = context.TopSequenceArg;
Value[] sequences = context.Sequences;
bool sequenceStackInUse = context.SequenceStackInUse;
context.PushSequenceFrame();
for (int i = topSequenceArg.basePtr; i <= topSequenceArg.endPtr; i++)
{
NodeSequence sequence = sequences[i].Sequence;
if (sequence.Count == 0)
{
if (!sequenceStackInUse)
{
context.PushSequence(NodeSequence.Empty);
}
}
else
{
NodeSequenceItem[] items = sequence.Items;
for (int j = 0; j < sequence.Count; j++)
{
SeekableXPathNavigator contextNode = items[j].GetNavigator();
NodeSequence destSequence = context.CreateSequence();
destSequence.StartNodeset();
base.criteria.Select(contextNode, destSequence);
destSequence.StopNodeset();
context.PushSequence(destSequence);
}
}
}
return(base.next);
}
internal override Opcode Eval(NodeSequence sequence, SeekableXPathNavigator node)
{
if ((base.next != null) && ((base.next.Flags & OpcodeFlags.CompressableSelect) != OpcodeFlags.None))
{
return(this.criteria.Select(node, sequence, (SelectOpcode)base.next));
}
sequence.StartNodeset();
this.criteria.Select(node, sequence);
sequence.StopNodeset();
return(base.next);
}
internal override Opcode Eval(ProcessingContext context)
{
context.PushContextSequenceFrame();
NodeSequence seq = context.CreateSequence();
seq.StartNodeset();
seq.Add(context.Processor.ContextNode);
seq.StopNodeset();
context.PushSequence(seq);
return(base.next);
}
internal override Opcode Eval(ProcessingContext context)
{
StackFrame topFrame = context.TopSequenceArg;
SeekableXPathNavigator node = null;
Value[] sequences = context.Sequences;
for (int i = topFrame.basePtr; i <= topFrame.endPtr; ++i)
{
// Each NodeSequence will generate a new one, but only if the source FilterSequence isn't empty
// If the source FilterSequence is empty, release it and replace it with an empty sequence
NodeSequence sourceSeq = sequences[i].Sequence;
int sourceSeqCount = sourceSeq.Count;
if (sourceSeqCount == 0)
{
context.ReplaceSequenceAt(i, NodeSequence.Empty);
context.ReleaseSequence(sourceSeq);
}
else
{
NodeSequenceItem[] items = sourceSeq.Items;
if (sourceSeq.CanReuse(context))
{
node = items[0].GetNavigator();
sourceSeq.Clear();
sourceSeq.StartNodeset();
this.criteria.Select(node, sourceSeq);
sourceSeq.StopNodeset();
}
else
{
NodeSequence newSeq = null;
for (int item = 0; item < sourceSeqCount; ++item)
{
node = items[item].GetNavigator();
Fx.Assert(null != node, "");
if (null == newSeq)
{
newSeq = context.CreateSequence();
}
newSeq.StartNodeset();
this.criteria.Select(node, newSeq);
newSeq.StopNodeset();
}
context.ReplaceSequenceAt(i, (null != newSeq) ? newSeq : NodeSequence.Empty);
context.ReleaseSequence(sourceSeq);
}
}
}
return(this.next);
}
internal override Opcode Eval(NodeSequence sequence, SeekableXPathNavigator node)
{
if (this.next == null || 0 == (this.next.Flags & OpcodeFlags.CompressableSelect))
{
// The next opcode is not a compressible select. Complete the select operation and return the next opcode
sequence.StartNodeset();
this.criteria.Select(node, sequence);
sequence.StopNodeset();
return(this.next);
}
return(this.criteria.Select(node, sequence, (SelectOpcode)this.next));
}
internal override Opcode Eval(ProcessingContext context)
{
StackFrame topSequenceArg = context.TopSequenceArg;
SeekableXPathNavigator contextNode = null;
Value[] sequences = context.Sequences;
for (int i = topSequenceArg.basePtr; i <= topSequenceArg.endPtr; i++)
{
NodeSequence sequence = sequences[i].Sequence;
int count = sequence.Count;
if (count == 0)
{
context.ReplaceSequenceAt(i, NodeSequence.Empty);
context.ReleaseSequence(sequence);
}
else
{
NodeSequenceItem[] items = sequence.Items;
if (sequence.CanReuse(context))
{
contextNode = items[0].GetNavigator();
sequence.Clear();
sequence.StartNodeset();
this.criteria.Select(contextNode, sequence);
sequence.StopNodeset();
}
else
{
NodeSequence destSequence = null;
for (int j = 0; j < count; j++)
{
contextNode = items[j].GetNavigator();
if (destSequence == null)
{
destSequence = context.CreateSequence();
}
destSequence.StartNodeset();
this.criteria.Select(contextNode, destSequence);
destSequence.StopNodeset();
}
context.ReplaceSequenceAt(i, (destSequence != null) ? destSequence : NodeSequence.Empty);
context.ReleaseSequence(sequence);
}
}
}
return(base.next);
}
internal override Opcode Eval(ProcessingContext context)
{
// The query processor object also serves as the query document root
int iterationCount = context.IterationCount;
Opcode returnOpcode = this.next;
// A root is always an initial step
context.PushSequenceFrame();
NodeSequence seq = context.CreateSequence();
if (this.next != null && 0 != (this.next.Flags & OpcodeFlags.CompressableSelect))
{
SeekableXPathNavigator node = context.Processor.ContextNode;
node.MoveToRoot();
returnOpcode = this.next.Eval(seq, node);
while (returnOpcode != null && 0 != (returnOpcode.Flags & OpcodeFlags.CompressableSelect))
{
returnOpcode = returnOpcode.Next;
}
}
else
{
// Roots do not have any qnames..
seq.StartNodeset();
SeekableXPathNavigator node = context.Processor.ContextNode;
node.MoveToRoot();
seq.Add(node);
seq.StopNodeset();
}
if (seq.Count == 0)
{
context.ReleaseSequence(seq);
seq = NodeSequence.Empty;
}
for (int i = 0; i < iterationCount; ++i)
{
context.PushSequence(seq);
}
if (iterationCount > 1)
{
seq.refCount += iterationCount - 1;
}
return(returnOpcode);
}
internal override Opcode Eval(ProcessingContext context)
{
StackFrame topFrame = context.TopSequenceArg;
Value[] sequences = context.Sequences;
bool wasInUse = context.SequenceStackInUse;
context.PushSequenceFrame();
for (int i = topFrame.basePtr; i <= topFrame.endPtr; ++i)
{
NodeSequence sourceSeq = sequences[i].Sequence;
int count = sourceSeq.Count;
if (count == 0)
{
// Empty sequence.
// Since there are no nodes in the sequence, we will track this sequence also
// using an empty sequence
if (!wasInUse)
{
context.PushSequence(NodeSequence.Empty);
}
}
else
{
NodeSequenceItem[] items = sourceSeq.Items;
for (int item = 0; item < sourceSeq.Count; ++item)
{
SeekableXPathNavigator node = items[item].GetNavigator();
Fx.Assert(null != node, "");
NodeSequence newSeq = context.CreateSequence();
newSeq.StartNodeset();
this.criteria.Select(node, newSeq);
newSeq.StopNodeset();
context.PushSequence(newSeq);
}
}
}
return(this.next);
}
internal override Opcode Eval(ProcessingContext context)
{
int iterationCount = context.IterationCount;
Opcode next = base.next;
context.PushSequenceFrame();
NodeSequence empty = context.CreateSequence();
if ((base.next != null) && ((base.next.Flags & OpcodeFlags.CompressableSelect) != OpcodeFlags.None))
{
SeekableXPathNavigator contextNode = context.Processor.ContextNode;
contextNode.MoveToRoot();
next = base.next.Eval(empty, contextNode);
while ((next != null) && ((next.Flags & OpcodeFlags.CompressableSelect) != OpcodeFlags.None))
{
next = next.Next;
}
}
else
{
empty.StartNodeset();
SeekableXPathNavigator node = context.Processor.ContextNode;
node.MoveToRoot();
empty.Add(node);
empty.StopNodeset();
}
if (empty.Count == 0)
{
context.ReleaseSequence(empty);
empty = NodeSequence.Empty;
}
for (int i = 0; i < iterationCount; i++)
{
context.PushSequence(empty);
}
if (iterationCount > 1)
{
empty.refCount += iterationCount - 1;
}
return(next);
}
internal override Opcode Eval(NodeSequence sequence, SeekableXPathNavigator node)
{
if (this.next == null || 0 == (this.next.Flags & OpcodeFlags.CompressableSelect))
{
// The next opcode is not a compressible select. Complete the select operation and return the next opcode
sequence.StartNodeset();
this.criteria.Select(node, sequence);
sequence.StopNodeset();
return this.next;
}
return this.criteria.Select(node, sequence, (SelectOpcode)this.next);
}
internal override Opcode Eval(NodeSequence sequence, SeekableXPathNavigator node)
{
if ((base.next != null) && ((base.next.Flags & OpcodeFlags.CompressableSelect) != OpcodeFlags.None))
{
return this.criteria.Select(node, sequence, (SelectOpcode) base.next);
}
sequence.StartNodeset();
this.criteria.Select(node, sequence);
sequence.StopNodeset();
return base.next;
}