internal override void InvokeInternal(ProcessingContext context, int argCount)
{
context.PushFrame();
int iterationCount = context.IterationCount;
if (iterationCount > 0)
{
string soapUri = context.Processor.SoapUri;
if (soapUri == null)
{
Message contextMessage = context.Processor.ContextMessage;
if (contextMessage == null)
{
SeekableXPathNavigator contextNode = context.Processor.ContextNode;
long currentPosition = contextNode.CurrentPosition;
soapUri = ExtractFromNavigator(contextNode);
contextNode.CurrentPosition = currentPosition;
}
else
{
soapUri = contextMessage.Version.Envelope.Namespace;
}
context.Processor.SoapUri = soapUri;
}
context.Push(soapUri, iterationCount);
}
}
internal override Opcode Eval(ProcessingContext context)
{
StackFrame topArg = context.TopArg;
bool flag = false;
if (1 == topArg.Count)
{
flag = context.Values[topArg.basePtr].ToBoolean();
}
else
{
context.Processor.Result = false;
for (int i = topArg.basePtr; i <= topArg.endPtr; i++)
{
if (context.Values[i].ToBoolean())
{
flag = true;
break;
}
}
}
if (flag)
{
ICollection<MessageFilter> matchSet = context.Processor.MatchSet;
int num2 = 0;
int count = this.results.Count;
while (num2 < count)
{
matchSet.Add((MessageFilter) this.results[num2]);
num2++;
}
}
context.PopFrame();
return base.next;
}
internal override void InvokeInternal(ProcessingContext context, int argCount)
{
StackFrame topArg = context.TopArg;
SeekableXPathNavigator contextNode = context.Processor.ContextNode;
long currentPosition = contextNode.CurrentPosition;
while (topArg.basePtr <= topArg.endPtr)
{
string str = context.PeekString(topArg.basePtr);
NodeSequence val = context.CreateSequence();
if (XPathMessageFunction.MoveToHeader(contextNode) && contextNode.MoveToFirstChild())
{
do
{
long num2 = contextNode.CurrentPosition;
string str2 = XPathMessageFunctionActor.ExtractFromNavigator(contextNode);
contextNode.CurrentPosition = num2;
if (str2 == str)
{
val.Add(contextNode);
}
}
while (contextNode.MoveToNext());
}
context.SetValue(context, topArg.basePtr, val);
topArg.basePtr++;
}
contextNode.CurrentPosition = currentPosition;
}
internal override void InvokeInternal(ProcessingContext context, int argCount)
{
context.PushFrame();
int iterationCount = context.IterationCount;
if (iterationCount > 0)
{
string messageId = context.Processor.MessageId;
if (messageId == null)
{
Message contextMessage = context.Processor.ContextMessage;
if (contextMessage == null)
{
SeekableXPathNavigator contextNode = context.Processor.ContextNode;
long currentPosition = contextNode.CurrentPosition;
messageId = ExtractFromNavigator(contextNode);
contextNode.CurrentPosition = currentPosition;
}
else
{
UniqueId id = contextMessage.Headers.MessageId;
if (id == null)
{
messageId = string.Empty;
}
else
{
messageId = id.ToString();
}
}
context.Processor.MessageId = messageId;
}
context.Push(messageId, iterationCount);
}
}
internal override Opcode Eval(ProcessingContext context)
{
XPathResult result;
StackFrame topArg = context.TopArg;
switch (context.Values[topArg.basePtr].Type)
{
case ValueDataType.Boolean:
result = new XPathResult(context.Values[topArg.basePtr].GetBoolean());
break;
case ValueDataType.Double:
result = new XPathResult(context.Values[topArg.basePtr].GetDouble());
break;
case ValueDataType.Sequence:
{
SafeNodeSequenceIterator nodeSetResult = new SafeNodeSequenceIterator(context.Values[topArg.basePtr].GetSequence(), context);
result = new XPathResult(nodeSetResult);
break;
}
case ValueDataType.String:
result = new XPathResult(context.Values[topArg.basePtr].GetString());
break;
default:
throw Fx.AssertAndThrow("Unexpected result type.");
}
context.Processor.ResultSet.Add(new KeyValuePair<MessageQuery, XPathResult>((MessageQuery) this.results[0], result));
for (int i = 1; i < this.results.Count; i++)
{
context.Processor.ResultSet.Add(new KeyValuePair<MessageQuery, XPathResult>((MessageQuery) this.results[i], result.Copy()));
}
context.PopFrame();
return base.next;
}
internal override void Eval(ProcessingContext context)
{
StackFrame[] frameArray = new StackFrame[this.argCount];
for (int i = 0; i < this.argCount; i++)
{
frameArray[i] = context[i];
}
StringBuilder builder = new StringBuilder();
while (frameArray[0].basePtr <= frameArray[0].endPtr)
{
builder.Length = 0;
for (int k = 0; k < this.argCount; k++)
{
builder.Append(context.PeekString(frameArray[k].basePtr));
}
context.SetValue(context, frameArray[this.argCount - 1].basePtr, builder.ToString());
for (int m = 0; m < this.argCount; m++)
{
frameArray[m].basePtr++;
}
}
for (int j = 0; j < (this.argCount - 1); j++)
{
context.PopFrame();
}
}
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, "RelatesTo"))
{
seq.Add(contextNode);
while (XPathMessageFunction.MoveToAddressingHeaderSibling(contextNode, "RelatesTo"))
{
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 BooleanLang(ProcessingContext context)
{
StackFrame topArg = context.TopArg;
StackFrame topSequenceArg = context.TopSequenceArg;
Value[] sequences = context.Sequences;
while (topSequenceArg.basePtr <= topSequenceArg.endPtr)
{
NodeSequence sequence = sequences[topSequenceArg.basePtr++].Sequence;
for (int i = 0; i < sequence.Count; i++)
{
string strA = context.PeekString(topArg.basePtr).ToUpperInvariant();
QueryNode node = sequence.Items[i].Node;
long currentPosition = node.Node.CurrentPosition;
node.Node.CurrentPosition = node.Position;
string strB = node.Node.XmlLang.ToUpperInvariant();
node.Node.CurrentPosition = currentPosition;
if ((strA.Length == strB.Length) && (string.CompareOrdinal(strA, strB) == 0))
{
context.SetValue(context, topArg.basePtr++, true);
}
else if (((strB.Length > 0) && (strA.Length < strB.Length)) && (strB.StartsWith(strA, StringComparison.Ordinal) && (strB[strA.Length] == '-')))
{
context.SetValue(context, topArg.basePtr++, true);
}
else
{
context.SetValue(context, topArg.basePtr++, false);
}
}
topSequenceArg.basePtr++;
}
}
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 void InvokeInternal(ProcessingContext context, int argCount)
{
context.PushFrame();
int iterationCount = context.IterationCount;
if (iterationCount > 0)
{
string toHeader = context.Processor.ToHeader;
if (toHeader == null)
{
Message contextMessage = context.Processor.ContextMessage;
if (contextMessage == null)
{
SeekableXPathNavigator contextNode = context.Processor.ContextNode;
long currentPosition = contextNode.CurrentPosition;
toHeader = ExtractFromNavigator(contextNode);
contextNode.CurrentPosition = currentPosition;
}
else
{
Uri to = contextMessage.Headers.To;
if (to == null)
{
toHeader = contextMessage.Version.Addressing.Anonymous;
}
else
{
toHeader = to.AbsoluteUri;
}
}
context.Processor.ToHeader = toHeader;
}
context.Push(toHeader, iterationCount);
}
}
internal override Opcode Eval(ProcessingContext context)
{
if (!context.LoadVariable(this.expr.Variable))
{
context.PushSequenceFrame();
NodeSequence seq = context.CreateSequence();
seq.Add(context.Processor.ContextNode);
context.PushSequence(seq);
int counterMarker = context.Processor.CounterMarker;
try
{
this.expr.Eval(context);
}
catch (XPathNavigatorException exception)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(exception.Process(this));
}
catch (NavigatorInvalidBodyAccessException exception2)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(exception2.Process(this));
}
context.Processor.CounterMarker = counterMarker;
context.PopSequenceFrame();
context.PopSequenceFrame();
context.LoadVariable(this.expr.Variable);
}
return base.next;
}
internal override Opcode Eval(ProcessingContext context)
{
XPathResult result;
StackFrame topArg = context.TopArg;
switch (context.Values[topArg.basePtr].Type)
{
case ValueDataType.Boolean:
result = new XPathResult(context.Values[topArg.basePtr].GetBoolean());
break;
case ValueDataType.Double:
result = new XPathResult(context.Values[topArg.basePtr].GetDouble());
break;
case ValueDataType.Sequence:
{
SafeNodeSequenceIterator nodeSetResult = new SafeNodeSequenceIterator(context.Values[topArg.basePtr].GetSequence(), context);
result = new XPathResult(nodeSetResult);
break;
}
case ValueDataType.String:
result = new XPathResult(context.Values[topArg.basePtr].GetString());
break;
default:
throw Fx.AssertAndThrow("Unexpected result type.");
}
context.Processor.QueryResult = result;
context.PopFrame();
return base.next;
}
public SafeNodeSequenceIterator(NodeSequence seq, ProcessingContext context) : base(seq)
{
this.context = context;
this.seq = seq;
Interlocked.Increment(ref this.seq.refCount);
this.context.Processor.AddRef();
}
internal override Opcode Eval(ProcessingContext context)
{
if (!context.LoadVariable(base.expr.Variable))
{
base.expr.Eval(context);
}
return base.next;
}
internal static void BooleanFalse(ProcessingContext context)
{
context.PushFrame();
int iterationCount = context.IterationCount;
if (iterationCount > 0)
{
context.Push(false, iterationCount);
}
}
internal override void InvokeInternal(ProcessingContext context, int argCount)
{
context.PushFrame();
int iterationCount = context.IterationCount;
if (iterationCount > 0)
{
context.Push(XPathMessageFunction.ConvertDate(DateTime.Now), iterationCount);
}
}
internal static void BooleanNot(ProcessingContext context)
{
StackFrame topArg = context.TopArg;
Value[] values = context.Values;
while (topArg.basePtr <= topArg.endPtr)
{
values[topArg.basePtr++].Not();
}
}
internal static void BooleanBoolean(ProcessingContext context)
{
StackFrame topArg = context.TopArg;
Value[] values = context.Values;
while (topArg.basePtr <= topArg.endPtr)
{
values[topArg.basePtr++].ConvertTo(context, ValueDataType.Boolean);
}
}
internal override Opcode Eval(ProcessingContext context)
{
context.PushFrame();
int iterationCount = context.IterationCount;
if (iterationCount > 0)
{
context.Push(this.literal, iterationCount);
}
return base.next;
}
internal override Opcode Eval(ProcessingContext context)
{
StackFrame topArg = context.TopArg;
Value[] values = context.Values;
for (int i = topArg.basePtr; i <= topArg.endPtr; i++)
{
values[i].ConvertTo(context, this.newType);
}
return base.next;
}
internal override Opcode Eval(ProcessingContext context)
{
Value[] values = context.Values;
StackFrame topArg = context.TopArg;
for (int i = topArg.basePtr; i <= topArg.endPtr; i++)
{
values[i].Update(context, values[i].CompareTo(this.literal, this.op));
}
return base.next;
}
internal override void InvokeInternal(ProcessingContext context, int argCount)
{
StackFrame topArg = context.TopArg;
while (topArg.basePtr <= topArg.endPtr)
{
string dateStr = context.PeekString(topArg.basePtr);
context.SetValue(context, topArg.basePtr, Convert(dateStr));
topArg.basePtr++;
}
}
internal override Opcode Eval(ProcessingContext context)
{
int num = this.UpdateResultMask(context);
context.PopFrame();
if (num == 0)
{
return base.Jump;
}
return base.next;
}
internal override Opcode Eval(ProcessingContext context)
{
SeekableXPathNavigator contextNode = context.Processor.ContextNode;
bool flag = this.Match(contextNode);
context.Processor.Result = flag;
if ((flag && (base.item != null)) && (context.Processor.MatchSet != null))
{
context.Processor.MatchSet.Add((MessageFilter) base.item);
}
return base.next;
}
internal override Opcode Eval(ProcessingContext context)
{
StackFrame topArg = context.TopArg;
for (int i = topArg.basePtr; i <= topArg.endPtr; i++)
{
if (this.test == context.Values[i].Boolean)
{
return base.next;
}
}
return base.Jump;
}
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 this.next;
}
internal override Opcode Eval(ProcessingContext context)
{
SeekableXPathNavigator contextNode = context.Processor.ContextNode;
XPathResult result = this.Select(contextNode);
if (context.Processor.ResultSet == null)
{
context.Processor.QueryResult = result;
}
else
{
context.Processor.ResultSet.Add(new KeyValuePair<MessageQuery, XPathResult>((MessageQuery) base.item, result));
}
return base.next;
}
internal override Opcode Eval(ProcessingContext context)
{
StackFrame topArg = context.TopArg;
StackFrame secondArg = context.SecondArg;
Value[] values = context.Values;
int basePtr = topArg.basePtr;
for (int i = secondArg.basePtr; basePtr <= topArg.endPtr; i++)
{
values[i].Add(values[basePtr].Double);
basePtr++;
}
context.PopFrame();
return base.next;
}
internal override Opcode Eval(ProcessingContext context)
{
StackFrame topArg = context.TopArg;
StackFrame secondArg = context.SecondArg;
Value[] values = context.Values;
while (topArg.basePtr <= topArg.endPtr)
{
values[secondArg.basePtr].Update(context, values[secondArg.basePtr].CompareTo(ref values[topArg.basePtr], this.op));
topArg.basePtr++;
secondArg.basePtr++;
}
context.PopFrame();
return base.next;
}
internal override Opcode Eval(ProcessingContext context)
{
NodeSequenceStack stack = context.SequenceStack;
StackFrame sequences = stack.TopArg;
stack.PushFrame();
for (int i = 0; i < sequences.count; ++i)
{
NodeSequence sourceSeq = stack.Sequences[sequences[i]];
sourceSeq.refCount++;
stack.Push(sourceSeq);
}
return this.next;
}
internal override Opcode Eval(ProcessingContext context)
{
StackFrame topSequenceArg = context.TopSequenceArg;
Value[] values = context.Values;
StackFrame topArg = context.TopArg;
Value[] sequences = context.Sequences;
context.PushSequenceFrame();
for (int i = topSequenceArg.basePtr; i <= topSequenceArg.endPtr; i++)
{
NodeSequence sequence = sequences[i].Sequence;
if (sequence.Count > 0)
{
NodeSequenceItem[] items = sequence.Items;
NodeSequence sequence2 = null;
int basePtr = topArg.basePtr;
for (int j = 0; basePtr <= topArg.endPtr; j++)
{
if (this.test == values[basePtr].Boolean)
{
if (sequence2 == null)
{
sequence2 = context.CreateSequence();
}
sequence2.AddCopy(ref items[j], NodeSequence.GetContextSize(sequence, j));
}
else if (items[j].Last && (sequence2 != null))
{
sequence2.Items[sequence2.Count - 1].Last = true;
}
basePtr++;
}
context.PushSequence((sequence2 == null) ? NodeSequence.Empty : sequence2);
sequence2 = null;
}
}
return(base.next);
}
internal override void InvokeInternal(ProcessingContext context, int argCount)
{
StackFrame topArg = context.TopArg;
while (topArg.basePtr <= topArg.endPtr)
{
bool val = false;
NodeSequence sequence = context.PeekSequence(topArg.basePtr);
if (sequence.Count > 0)
{
NodeSequenceItem item = sequence[0];
SeekableXPathNavigator node = item.Node.Node;
long currentPosition = node.CurrentPosition;
NodeSequenceItem item2 = sequence[0];
node.CurrentPosition = item2.Node.Position;
val = ExtractFromNavigator(node);
node.CurrentPosition = currentPosition;
}
context.SetValue(context, topArg.basePtr, val);
topArg.basePtr++;
}
}
internal override Opcode Eval(ProcessingContext context)
{
StackFrame topSequenceArg = context.TopSequenceArg;
StackFrame topArg = context.TopArg;
Value[] sequences = context.Sequences;
int basePtr = topSequenceArg.basePtr;
int index = topArg.basePtr;
while (basePtr <= topSequenceArg.endPtr)
{
NodeSequence sequence = sequences[basePtr].Sequence;
for (int i = 0; i < sequence.Count; i++)
{
NodeSequenceItem item = sequence[i];
context.Values[index].Boolean = item.Position == context.Values[index].Double;
index++;
}
basePtr++;
}
return(base.next);
}
internal bool LoadVariable(ProcessingContext context, int var)
{
if (this.subExprVars[var].seq == null)
{
return(false);
}
int iter = context.IterationCount;
this.counter.IncreaseBy(iter * this.subExprVars[var].count);
NodeSequence seq = this.subExprVars[var].seq;
context.PushSequenceFrame();
for (int i = 0; i < iter; ++i)
{
seq.refCount++;
context.PushSequence(seq);
}
return(true);
}
protected bool IsSuccess(ProcessingContext context)
{
StackFrame topFrame = context.TopArg;
if (1 == topFrame.Count)
{
return(context.Values[topFrame.basePtr].ToBoolean());
}
else
{
context.Processor.Result = false;
for (int i = topFrame.basePtr; i <= topFrame.endPtr; ++i)
{
if (context.Values[i].ToBoolean())
{
return(true);
}
}
}
return(false);
}
internal override Opcode Eval(ProcessingContext context)
{
StackFrame topSequenceArg = context.TopSequenceArg;
StackFrame topArg = context.TopArg;
NodeSequenceBuilder builder = new NodeSequenceBuilder(context);
Value[] sequences = context.Sequences;
int basePtr = topSequenceArg.basePtr;
int index = topArg.basePtr;
while (basePtr <= topSequenceArg.endPtr)
{
NodeSequence sequence = sequences[basePtr].Sequence;
if (sequence.Count > 0)
{
NodesetIterator iterator = new NodesetIterator(sequence);
while (iterator.NextNodeset())
{
builder.StartNodeset();
while (iterator.NextItem())
{
if (context.Values[index].Boolean)
{
builder.Add(ref sequence.Items[iterator.Index]);
}
index++;
}
builder.EndNodeset();
}
context.ReplaceSequenceAt(basePtr, builder.Sequence);
context.ReleaseSequence(sequence);
builder.Sequence = null;
}
basePtr++;
}
context.PopFrame();
return(base.next);
}
internal static void BooleanLang(ProcessingContext context)
{
StackFrame langArg = context.TopArg;
StackFrame sequences = context.TopSequenceArg;
Value[] sequenceBuffer = context.Sequences;
while (sequences.basePtr <= sequences.endPtr)
{
NodeSequence sourceSeq = sequenceBuffer[sequences.basePtr++].Sequence;
for (int item = 0; item < sourceSeq.Count; ++item)
{
string lang = context.PeekString(langArg.basePtr).ToUpperInvariant();
QueryNode node = sourceSeq.Items[item].Node;
long pos = node.Node.CurrentPosition;
node.Node.CurrentPosition = node.Position;
string docLang = node.Node.XmlLang.ToUpperInvariant();
node.Node.CurrentPosition = pos;
if (lang.Length == docLang.Length && string.CompareOrdinal(lang, docLang) == 0)
{
context.SetValue(context, langArg.basePtr++, true);
}
else if (docLang.Length > 0 && lang.Length < docLang.Length && docLang.StartsWith(lang, StringComparison.Ordinal) && docLang[lang.Length] == '-')
{
context.SetValue(context, langArg.basePtr++, true);
}
else
{
context.SetValue(context, langArg.basePtr++, false);
}
}
sequences.basePtr++;
}
}
internal static void Translate(ProcessingContext context)
{
StackFrame argSource = context.TopArg;
StackFrame argKeys = context.SecondArg;
StackFrame argValues = context[2];
// PERF, [....], this is really slow.
StringBuilder builder = new StringBuilder();
while (argSource.basePtr <= argSource.endPtr)
{
builder.Length = 0;
string source = context.PeekString(argSource.basePtr);
string keys = context.PeekString(argKeys.basePtr);
string values = context.PeekString(argValues.basePtr);
for (int i = 0; i < source.Length; ++i)
{
char c = source[i];
int idx = keys.IndexOf(c);
if (idx < 0)
{
builder.Append(c);
}
else if (idx < values.Length)
{
builder.Append(values[idx]);
}
}
context.SetValue(context, argValues.basePtr, builder.ToString());
argSource.basePtr++;
argKeys.basePtr++;
argValues.basePtr++;
}
context.PopFrame();
context.PopFrame();
}
void InvokeSingleMatch(ProcessingContext context)
{
int marker = context.Processor.CounterMarker;
QueryBranchResult result = this.resultTable[0];
this.InitResults(context);
context.Values[context.TopArg[result.ValIndex]].Boolean = true;
try
{
context.EvalCodeBlock(result.Branch.Branch.Next);
}
catch (XPathNavigatorException e)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(e.Process(result.Branch.Branch.Next));
}
catch (NavigatorInvalidBodyAccessException e)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(e.Process(result.Branch.Branch.Next));
}
context.Processor.CounterMarker = marker;
}
protected int UpdateResultMask(ProcessingContext context)
{
StackFrame results = context.TopArg;
StackFrame resultMask = context.SecondArg;
Value[] values = context.Values;
int testCount = 0;
for (int maskIndex = resultMask.basePtr, resultIndex = results.basePtr; maskIndex <= resultMask.endPtr; ++maskIndex)
{
if (this.test == values[maskIndex].Boolean)
{
bool boolResult = values[resultIndex].Boolean;
if (this.test == boolResult)
{
testCount++;
}
values[maskIndex].Boolean = boolResult;
++resultIndex;
}
}
return(testCount);
}
internal void CopyFrom(ProcessingContext context)
{
Fx.Assert(null != context, "");
this.processor = context.processor;
if (context.sequenceStack.frames.Count > 0)
{
this.sequenceStack.CopyFrom(ref context.sequenceStack);
}
else
{
this.sequenceStack.Clear();
}
if (context.valueStack.frames.Count > 0)
{
this.valueStack.CopyFrom(ref context.valueStack);
}
else
{
this.valueStack.Clear();
}
this.nodeCount = context.nodeCount;
}
internal static void StringConcatFour(ProcessingContext context)
{
StackFrame arg1 = context[0];
StackFrame arg2 = context[1];
StackFrame arg3 = context[2];
StackFrame arg4 = context[3];
while (arg1.basePtr <= arg1.endPtr)
{
string str1 = context.PeekString(arg1.basePtr);
string str2 = context.PeekString(arg2.basePtr);
string str3 = context.PeekString(arg3.basePtr);
string str4 = context.PeekString(arg4.basePtr);
context.SetValue(context, arg4.basePtr, str1 + str2 + str3 + str4);
arg1.basePtr++;
arg2.basePtr++;
arg3.basePtr++;
arg4.basePtr++;
}
context.PopFrame();
context.PopFrame();
context.PopFrame();
}
internal void Eval(ProcessingContext context)
{
int count = 0, marker = context.Processor.CounterMarker;
Opcode op = this.ops;
if (this.useSpecial)
{
op.EvalSpecial(context);
context.LoadVariable(this.var);
//context.Processor.CounterMarker = marker;
return;
}
while (op != null)
{
op = op.Eval(context);
}
count = context.Processor.ElapsedCount(marker);
//context.Processor.CounterMarker = marker;
context.SaveVariable(this.var, count);
}
internal override Opcode Eval(ProcessingContext context)
{
Value[] values = context.Values;
StackFrame arg = context.TopArg;
for (int i = arg.basePtr; i <= arg.endPtr; ++i)
{
Fx.Assert(ValueDataType.Sequence == values[i].Type, "");
NodeSequence seq = values[i].Sequence;
NodeSequence newSeq = context.CreateSequence();
for (int j = 0; j < seq.Count; ++j)
{
NodeSequenceItem item = seq[j];
newSeq.AddCopy(ref item);
}
newSeq.Merge();
context.SetValue(context, i, newSeq);
}
return(this.next);
}
internal override Opcode Eval(ProcessingContext context)
{
StackFrame arg = context.TopArg;
if (1 == arg.Count)
{
Fx.Assert(context.Values[arg.basePtr].IsType(ValueDataType.String), "");
string target = context.Values[arg.basePtr].String;
context.Values[arg.basePtr].Boolean = target.StartsWith(this.literal, StringComparison.Ordinal);
}
else
{
for (int i = arg.basePtr; i <= arg.endPtr; ++i)
{
Fx.Assert(context.Values[i].IsType(ValueDataType.String), "");
string target = context.Values[i].String;
context.Values[i].Boolean = target.StartsWith(this.literal, StringComparison.Ordinal);
}
}
return(this.next);
}
internal override Opcode Eval(ProcessingContext context)
{
StackFrame sequences = context.TopSequenceArg;
StackFrame results = context.TopArg;
NodeSequenceBuilder sequenceBuilder = new NodeSequenceBuilder(context);
Value[] sequenceBuffer = context.Sequences;
for (int seqIndex = sequences.basePtr, resultIndex = results.basePtr; seqIndex <= sequences.endPtr; ++seqIndex)
{
NodeSequence sourceSequence = sequenceBuffer[seqIndex].Sequence;
if (sourceSequence.Count > 0)
{
NodesetIterator nodesetIterator = new NodesetIterator(sourceSequence);
while (nodesetIterator.NextNodeset())
{
sequenceBuilder.StartNodeset();
while (nodesetIterator.NextItem())
{
Fx.Assert(context.Values[resultIndex].IsType(ValueDataType.Boolean), "");
if (context.Values[resultIndex].Boolean)
{
sequenceBuilder.Add(ref sourceSequence.Items[nodesetIterator.Index]);
}
++resultIndex;
}
sequenceBuilder.EndNodeset();
}
context.ReplaceSequenceAt(seqIndex, sequenceBuilder.Sequence);
context.ReleaseSequence(sourceSequence);
sequenceBuilder.Sequence = null;
}
}
context.PopFrame();
return(this.next);
}
internal override Opcode Eval(ProcessingContext context)
{
XPathResult result;
StackFrame topArg = context.TopArg;
switch (context.Values[topArg.basePtr].Type)
{
case ValueDataType.Boolean:
result = new XPathResult(context.Values[topArg.basePtr].GetBoolean());
break;
case ValueDataType.Double:
result = new XPathResult(context.Values[topArg.basePtr].GetDouble());
break;
case ValueDataType.Sequence:
{
SafeNodeSequenceIterator nodeSetResult = new SafeNodeSequenceIterator(context.Values[topArg.basePtr].GetSequence(), context);
result = new XPathResult(nodeSetResult);
break;
}
case ValueDataType.String:
result = new XPathResult(context.Values[topArg.basePtr].GetString());
break;
default:
throw Fx.AssertAndThrow("Unexpected result type.");
}
context.Processor.ResultSet.Add(new KeyValuePair <MessageQuery, XPathResult>((MessageQuery)this.results[0], result));
for (int i = 1; i < this.results.Count; i++)
{
context.Processor.ResultSet.Add(new KeyValuePair <MessageQuery, XPathResult>((MessageQuery)this.results[i], result.Copy()));
}
context.PopFrame();
return(base.next);
}
internal void InvokeNonMatches(ProcessingContext context, QueryBranchTable nonMatchTable)
{
int counterMarker = context.Processor.CounterMarker;
BranchContext context2 = new BranchContext(context);
int num2 = 0;
int num3 = 0;
while ((num3 < this.resultTable.Count) && (num2 < nonMatchTable.Count))
{
QueryBranchResult result = this.resultTable[num3];
int num4 = result.Branch.ID - nonMatchTable[num2].ID;
if (num4 > 0)
{
ProcessingContext context3 = context2.Create();
this.InvokeNonMatch(context3, nonMatchTable[num2]);
context.Processor.CounterMarker = counterMarker;
num2++;
}
else
{
if (num4 == 0)
{
num2++;
continue;
}
num3++;
}
}
while (num2 < nonMatchTable.Count)
{
ProcessingContext context4 = context2.Create();
this.InvokeNonMatch(context4, nonMatchTable[num2]);
context.Processor.CounterMarker = counterMarker;
num2++;
}
context2.Release();
}
internal static void SubstringLimit(ProcessingContext context)
{
StackFrame argString = context.TopArg;
StackFrame argStartAt = context.SecondArg;
StackFrame argLimit = context[2];
Fx.Assert(argString.Count == argStartAt.Count, "");
Fx.Assert(argString.Count == argLimit.Count, "");
while (argString.basePtr <= argString.endPtr)
{
string str = context.PeekString(argString.basePtr);
int startAt = ((int)Math.Round(context.PeekDouble(argStartAt.basePtr))) - 1;
if (startAt < 0)
{
startAt = 0;
}
int length = (int)Math.Round(context.PeekDouble(argLimit.basePtr));
string substr;
if (length < 1 || ((startAt + length) >= str.Length))
{
substr = string.Empty;
}
else
{
substr = str.Substring(startAt, length);
}
context.SetValue(context, argLimit.basePtr, substr);
argStartAt.basePtr++;
argString.basePtr++;
argLimit.basePtr++;
}
context.PopFrame();
context.PopFrame();
}
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.MoveToHeader(contextNode))
{
seq.Add(contextNode);
}
contextNode.CurrentPosition = currentPosition;
seq.StopNodeset();
context.PushSequence(seq);
for (int i = 1; i < iterationCount; i++)
{
context.PushSequence(seq);
}
}
}
internal NodeSequenceBuilder(ProcessingContext context)
: this(context, null)
{
}
internal override Opcode EvalSpecial(ProcessingContext context)
{
this.expr.EvalSpecial(context);
return(this.next);
}
internal override void EvalSpecial(ProcessingContext context)
{
int marker = context.Processor.CounterMarker;
if (!context.LoadVariable(this.var))
{
XPathMessageContext.HeaderFun.InvokeInternal(context, 0);
context.SaveVariable(this.var, context.Processor.ElapsedCount(marker));
}
// WS, Microsoft, see if we can put this array in the processor to save
// an allocation. Perhaps we can use the variables slot we're going to fill
NodeSequence[] childSequences = new NodeSequence[this.children.Count];
NodeSequence seq = context.Sequences[context.TopSequenceArg.basePtr].Sequence;
for (int i = 0; i < this.children.Count; ++i)
{
childSequences[i] = context.CreateSequence();
childSequences[i].StartNodeset();
}
// Perform the index
SeekableXPathNavigator nav = seq[0].GetNavigator();
if (nav.MoveToFirstChild())
{
do
{
if (nav.NodeType == XPathNodeType.Element)
{
List <SubExpr> lst;
string name = nav.LocalName;
string ns = nav.NamespaceURI;
Dictionary <string, List <SubExpr> > nextLookup;
if (this.nameLookup.TryGetValue(ns, out nextLookup))
{
if (nextLookup.TryGetValue(name, out lst))
{
for (int i = 0; i < lst.Count; ++i)
{
childSequences[this.indexLookup[lst[i]].i].Add(nav);
}
}
if (nextLookup.TryGetValue(QueryDataModel.Wildcard, out lst))
{
for (int i = 0; i < lst.Count; ++i)
{
childSequences[this.indexLookup[lst[i]].i].Add(nav);
}
}
}
if (this.nameLookup.TryGetValue(QueryDataModel.Wildcard, out nextLookup))
{
if (nextLookup.TryGetValue(QueryDataModel.Wildcard, out lst))
{
for (int i = 0; i < lst.Count; ++i)
{
childSequences[this.indexLookup[lst[i]].i].Add(nav);
}
}
}
}
} while (nav.MoveToNext());
}
int secondMarker = context.Processor.CounterMarker;
for (int i = 0; i < this.children.Count; ++i)
{
if (this.children[i].useSpecial)
{
childSequences[i].StopNodeset();
context.Processor.CounterMarker = secondMarker;
context.PushSequenceFrame();
context.PushSequence(childSequences[i]);
Opcode op = this.children[i].FirstOp.Next;
while (op != null)
{
op = op.Eval(context);
}
context.SaveVariable(this.children[i].var, context.Processor.ElapsedCount(marker));
context.PopSequenceFrame();
}
else
{
context.ReleaseSequence(childSequences[i]);
//context.SetVariable(this.children[i].Variable, null, 0);
}
}
context.Processor.CounterMarker = marker;
}
internal void SetValue(ProcessingContext context, int index, NodeSequence val)
{
this.valueStack.SetValue(this, index, val);
}
internal void SetValue(ProcessingContext context, int index, string val)
{
this.valueStack.SetValue(this, index, val);
}
internal void SetValue(ProcessingContext context, int index, NodeSequence val)
{
this.buffer.buffer[index].Update(context, val);
}
internal void SetValue(ProcessingContext context, int index, string val)
{
this.buffer.buffer[index].Update(context, val);
}
internal bool CanReuse(ProcessingContext context)
{
return(this.count == 1 && this.ownerContext == context && this.refCount == 1);
}
internal void SetValue(ProcessingContext context, int index, NodeSequence val)
{
Fx.Assert(this.stack.IsValidStackPtr(index), "");
this.buffer.buffer[index].Update(context, val);
}
internal NodeSequenceBuilder(ProcessingContext context, NodeSequence sequence)
{
this.context = context;
this.sequence = sequence;
}
