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 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 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 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 static void NormalizeSpace(ProcessingContext context)
{
StackFrame argStr = context.TopArg;
StringBuilder builder = new StringBuilder();
while (argStr.basePtr <= argStr.endPtr)
{
char[] whitespace = new char[] { ' ', '\t', '\r', '\n' };
string str = context.PeekString(argStr.basePtr).Trim(whitespace);
bool eatingWhitespace = false;
builder.Length = 0;
for (int i = 0; i < str.Length; ++i)
{
char c = str[i];
if (XPathCharTypes.IsWhitespace(c))
{
if (!eatingWhitespace)
{
builder.Append(' ');
eatingWhitespace = true;
}
}
else
{
builder.Append(c);
eatingWhitespace = false;
}
}
context.SetValue(context, argStr.basePtr, builder.ToString());
argStr.basePtr++;
}
}
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 Eval(ProcessingContext context)
{
Fx.Assert(context != null, "");
StackFrame[] args = new StackFrame[argCount];
for (int i = 0; i < this.argCount; ++i)
{
args[i] = context[i];
}
StringBuilder builder = new StringBuilder();
while (args[0].basePtr <= args[0].endPtr)
{
builder.Length = 0;
for (int i = 0; i < this.argCount; ++i)
{
builder.Append(context.PeekString(args[i].basePtr));
}
context.SetValue(context, args[this.argCount - 1].basePtr, builder.ToString());
for (int i = 0; i < this.argCount; ++i)
{
args[i].basePtr++;
}
}
for (int i = 0; i < this.argCount - 1; ++i)
{
context.PopFrame();
}
}
internal static void SubstringLimit(ProcessingContext context)
{
StackFrame topArg = context.TopArg;
StackFrame secondArg = context.SecondArg;
StackFrame frame3 = context[2];
while (topArg.basePtr <= topArg.endPtr)
{
string str2;
string str = context.PeekString(topArg.basePtr);
int startIndex = ((int)Math.Round(context.PeekDouble(secondArg.basePtr))) - 1;
if (startIndex < 0)
{
startIndex = 0;
}
int length = (int)Math.Round(context.PeekDouble(frame3.basePtr));
if ((length < 1) || ((startIndex + length) >= str.Length))
{
str2 = string.Empty;
}
else
{
str2 = str.Substring(startIndex, length);
}
context.SetValue(context, frame3.basePtr, str2);
secondArg.basePtr++;
topArg.basePtr++;
frame3.basePtr++;
}
context.PopFrame();
context.PopFrame();
}
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 static void Translate(ProcessingContext context)
{
StackFrame topArg = context.TopArg;
StackFrame secondArg = context.SecondArg;
StackFrame frame3 = context[2];
StringBuilder builder = new StringBuilder();
while (topArg.basePtr <= topArg.endPtr)
{
builder.Length = 0;
string str = context.PeekString(topArg.basePtr);
string str2 = context.PeekString(secondArg.basePtr);
string str3 = context.PeekString(frame3.basePtr);
for (int i = 0; i < str.Length; i++)
{
char ch = str[i];
int index = str2.IndexOf(ch);
if (index < 0)
{
builder.Append(ch);
}
else if (index < str3.Length)
{
builder.Append(str3[index]);
}
}
context.SetValue(context, frame3.basePtr, builder.ToString());
topArg.basePtr++;
secondArg.basePtr++;
frame3.basePtr++;
}
context.PopFrame();
context.PopFrame();
}
internal static void NormalizeSpace(ProcessingContext context)
{
StackFrame topArg = context.TopArg;
StringBuilder builder = new StringBuilder();
while (topArg.basePtr <= topArg.endPtr)
{
char[] trimChars = new char[] { ' ', '\t', '\r', '\n' };
string str = context.PeekString(topArg.basePtr).Trim(trimChars);
bool flag = false;
builder.Length = 0;
for (int i = 0; i < str.Length; i++)
{
char c = str[i];
if (XPathCharTypes.IsWhitespace(c))
{
if (!flag)
{
builder.Append(' ');
flag = true;
}
}
else
{
builder.Append(c);
flag = false;
}
}
context.SetValue(context, topArg.basePtr, builder.ToString());
topArg.basePtr++;
}
}
internal static void NodesetCount(ProcessingContext context)
{
StackFrame arg = context.TopArg;
while (arg.basePtr <= arg.endPtr)
{
context.SetValue(context, arg.basePtr, context.PeekSequence(arg.basePtr).Count);
arg.basePtr++;
}
}
internal static void NumberFloor(ProcessingContext context)
{
StackFrame topArg = context.TopArg;
while (topArg.basePtr <= topArg.endPtr)
{
context.SetValue(context, topArg.basePtr, Math.Floor(context.PeekDouble(topArg.basePtr)));
topArg.basePtr++;
}
}
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 static void NodesetCount(ProcessingContext context)
{
StackFrame topArg = context.TopArg;
while (topArg.basePtr <= topArg.endPtr)
{
context.SetValue(context, topArg.basePtr, (double)context.PeekSequence(topArg.basePtr).Count);
topArg.basePtr++;
}
}
internal static void StringLength(ProcessingContext context)
{
StackFrame arg = context.TopArg;
while (arg.basePtr <= arg.endPtr)
{
context.SetValue(context, arg.basePtr, context.PeekString(arg.basePtr).Length);
arg.basePtr++;
}
}
internal static void StringLength(ProcessingContext context)
{
StackFrame topArg = context.TopArg;
while (topArg.basePtr <= topArg.endPtr)
{
context.SetValue(context, topArg.basePtr, (double)context.PeekString(topArg.basePtr).Length);
topArg.basePtr++;
}
}
internal static void NumberCeiling(ProcessingContext context)
{
StackFrame arg = context.TopArg;
while (arg.basePtr <= arg.endPtr)
{
context.SetValue(context, arg.basePtr, Math.Ceiling(context.PeekDouble(arg.basePtr)));
arg.basePtr++;
}
}
internal override void InvokeInternal(ProcessingContext context, int argCount)
{
StackFrame topArg = context.TopArg;
while (topArg.basePtr <= topArg.endPtr)
{
string spanStr = context.PeekString(topArg.basePtr);
context.SetValue(context, topArg.basePtr, Convert(spanStr));
topArg.basePtr++;
}
}
internal static void NodesetName(ProcessingContext context)
{
StackFrame arg = context.TopArg;
while (arg.basePtr <= arg.endPtr)
{
NodeSequence sequence = context.PeekSequence(arg.basePtr);
context.SetValue(context, arg.basePtr, sequence.Name);
arg.basePtr++;
}
}
internal static void NodesetNamespaceUri(ProcessingContext context)
{
StackFrame topArg = context.TopArg;
while (topArg.basePtr <= topArg.endPtr)
{
NodeSequence sequence = context.PeekSequence(topArg.basePtr);
context.SetValue(context, topArg.basePtr, sequence.Namespace);
topArg.basePtr++;
}
}
internal static void NumberRound(ProcessingContext context)
{
StackFrame topArg = context.TopArg;
while (topArg.basePtr <= topArg.endPtr)
{
context.PeekDouble(topArg.basePtr);
context.SetValue(context, topArg.basePtr, QueryValueModel.Round(context.PeekDouble(topArg.basePtr)));
topArg.basePtr++;
}
}
internal static void StringConcatTwo(ProcessingContext context)
{
StackFrame frame = context[0];
StackFrame frame2 = context[1];
while (frame.basePtr <= frame.endPtr)
{
context.SetValue(context, frame2.basePtr, context.PeekString(frame.basePtr) + context.PeekString(frame2.basePtr));
frame.basePtr++;
frame2.basePtr++;
}
context.PopFrame();
}
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 StringConcatTwo(ProcessingContext context)
{
StackFrame arg1 = context[0];
StackFrame arg2 = context[1];
while (arg1.basePtr <= arg1.endPtr)
{
string str1 = context.PeekString(arg1.basePtr);
string str2 = context.PeekString(arg2.basePtr);
context.SetValue(context, arg2.basePtr, str1 + str2);
arg1.basePtr++;
arg2.basePtr++;
}
context.PopFrame();
}
internal static void StringStartsWith(ProcessingContext context)
{
StackFrame topArg = context.TopArg;
StackFrame secondArg = context.SecondArg;
while (topArg.basePtr <= topArg.endPtr)
{
string str = context.PeekString(topArg.basePtr);
string str2 = context.PeekString(secondArg.basePtr);
context.SetValue(context, secondArg.basePtr, str.StartsWith(str2, StringComparison.Ordinal));
topArg.basePtr++;
secondArg.basePtr++;
}
context.PopFrame();
}
internal override Opcode Eval(ProcessingContext context)
{
StackFrame topArg = context.TopArg;
StackFrame secondArg = context.SecondArg;
int basePtr = topArg.basePtr;
for (int i = secondArg.basePtr; basePtr <= topArg.endPtr; i++)
{
NodeSequence otherSeq = context.Values[basePtr].Sequence;
NodeSequence sequence = context.Values[i].Sequence;
context.SetValue(context, i, sequence.Union(context, otherSeq));
basePtr++;
}
context.PopFrame();
return base.next;
}
internal static void SubstringBefore(ProcessingContext context)
{
StackFrame topArg = context.TopArg;
StackFrame secondArg = context.SecondArg;
while (topArg.basePtr <= topArg.endPtr)
{
string str = context.PeekString(topArg.basePtr);
string str2 = context.PeekString(secondArg.basePtr);
int index = str.IndexOf(str2, StringComparison.Ordinal);
context.SetValue(context, secondArg.basePtr, (index == -1) ? string.Empty : str.Substring(0, index));
topArg.basePtr++;
secondArg.basePtr++;
}
context.PopFrame();
}
internal static void StringStartsWith(ProcessingContext context)
{
StackFrame arg1 = context.TopArg;
StackFrame arg2 = context.SecondArg;
Fx.Assert(arg1.Count == arg2.Count, "");
while (arg1.basePtr <= arg1.endPtr)
{
string leftString = context.PeekString(arg1.basePtr);
string rightString = context.PeekString(arg2.basePtr);
context.SetValue(context, arg2.basePtr, leftString.StartsWith(rightString, StringComparison.Ordinal));
arg1.basePtr++;
arg2.basePtr++;
}
context.PopFrame();
}
internal override Opcode Eval(ProcessingContext context)
{
StackFrame topArg = context.TopArg;
StackFrame secondArg = context.SecondArg;
int basePtr = topArg.basePtr;
for (int i = secondArg.basePtr; basePtr <= topArg.endPtr; i++)
{
NodeSequence otherSeq = context.Values[basePtr].Sequence;
NodeSequence sequence = context.Values[i].Sequence;
context.SetValue(context, i, sequence.Union(context, otherSeq));
basePtr++;
}
context.PopFrame();
return(base.next);
}
internal static void SubstringAfter(ProcessingContext context)
{
StackFrame arg1 = context.TopArg;
StackFrame arg2 = context.SecondArg;
Fx.Assert(arg1.Count == arg2.Count, "");
while (arg1.basePtr <= arg1.endPtr)
{
string str1 = context.PeekString(arg1.basePtr);
string str2 = context.PeekString(arg2.basePtr);
int idx = str1.IndexOf(str2, StringComparison.Ordinal);
context.SetValue(context, arg2.basePtr, idx == -1 ? string.Empty : str1.Substring(idx + str2.Length));
arg1.basePtr++;
arg2.basePtr++;
}
context.PopFrame();
}
internal static void NumberSum(ProcessingContext context)
{
StackFrame arg = context.TopArg;
while (arg.basePtr <= arg.endPtr)
{
NodeSequence sequence = context.PeekSequence(arg.basePtr);
double sum = 0.0;
for (int item = 0; item < sequence.Count; ++item)
{
sum += QueryValueModel.Double(sequence[item].StringValue());
}
context.SetValue(context, arg.basePtr, sum);
arg.basePtr++;
}
}
internal override void InvokeInternal(ProcessingContext context, int argCount)
{
StackFrame topArg = context.TopArg;
Message contextMessage = context.Processor.ContextMessage;
CorrelationDataMessageProperty property = null;
CorrelationDataMessageProperty.TryGet(contextMessage, out property);
while (topArg.basePtr <= topArg.endPtr)
{
string str;
if ((property == null) || !property.TryGetValue(context.PeekString(topArg.basePtr), out str))
{
str = string.Empty;
}
context.SetValue(context, topArg.basePtr, str);
topArg.basePtr++;
}
}
internal static void NumberSum(ProcessingContext context)
{
StackFrame topArg = context.TopArg;
while (topArg.basePtr <= topArg.endPtr)
{
NodeSequence sequence = context.PeekSequence(topArg.basePtr);
double val = 0.0;
for (int i = 0; i < sequence.Count; i++)
{
NodeSequenceItem item = sequence[i];
val += QueryValueModel.Double(item.StringValue());
}
context.SetValue(context, topArg.basePtr, val);
topArg.basePtr++;
}
}
internal override void InvokeInternal(ProcessingContext context, int argCount)
{
StackFrame topArg = context.TopArg;
Message contextMessage = context.Processor.ContextMessage;
CorrelationDataMessageProperty property = null;
CorrelationDataMessageProperty.TryGet(contextMessage, out property);
while (topArg.basePtr <= topArg.endPtr)
{
string str;
if ((property == null) || !property.TryGetValue(context.PeekString(topArg.basePtr), out str))
{
str = string.Empty;
}
context.SetValue(context, topArg.basePtr, str);
topArg.basePtr++;
}
}
internal override Opcode Eval(ProcessingContext context)
{
StackFrame topArg = context.TopArg;
StackFrame secondArg = context.SecondArg;
Fx.Assert(topArg.Count == secondArg.Count, "");
for (int x = topArg.basePtr, y = secondArg.basePtr; x <= topArg.endPtr; ++x, ++y)
{
NodeSequence seqX = context.Values[x].Sequence;
NodeSequence seqY = context.Values[y].Sequence;
// Replace with a new sequence that is the union of the two
context.SetValue(context, y, seqY.Union(context, seqX));
}
context.PopFrame();
return(this.next);
}
internal override Opcode Eval(ProcessingContext context)
{
Value[] values = context.Values;
StackFrame topArg = context.TopArg;
for (int i = topArg.basePtr; i <= topArg.endPtr; i++)
{
NodeSequence sequence = values[i].Sequence;
NodeSequence val = context.CreateSequence();
for (int j = 0; j < sequence.Count; j++)
{
NodeSequenceItem item = sequence[j];
val.AddCopy(ref item);
}
val.Merge();
context.SetValue(context, i, val);
}
return base.next;
}
internal override void InvokeInternal(ProcessingContext context, int argCount)
{
StackFrame topArg = context.TopArg;
while (topArg.basePtr <= topArg.endPtr)
{
string val = string.Empty;
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 static void NumberRound(ProcessingContext context)
{
StackFrame arg = context.TopArg;
while (arg.basePtr <= arg.endPtr)
{
double val = context.PeekDouble(arg.basePtr);
context.SetValue(context, arg.basePtr, QueryValueModel.Round(context.PeekDouble(arg.basePtr)));
arg.basePtr++;
}
}
internal override void InvokeInternal(ProcessingContext context, int argCount)
{
StackFrame seqArg = context.TopArg;
while (seqArg.basePtr <= seqArg.endPtr)
{
string actor = string.Empty;
NodeSequence seq = context.PeekSequence(seqArg.basePtr);
if (seq.Count > 0)
{
SeekableXPathNavigator nav = seq[0].Node.Node;
long p = nav.CurrentPosition;
nav.CurrentPosition = seq[0].Node.Position;
actor = ExtractFromNavigator(nav);
nav.CurrentPosition = p;
}
context.SetValue(context, seqArg.basePtr, actor);
seqArg.basePtr++;
}
}
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 override Opcode Eval(ProcessingContext context)
{
StackFrame topArg = context.TopArg;
StackFrame secondArg = context.SecondArg;
Fx.Assert(topArg.Count == secondArg.Count, "");
for (int x = topArg.basePtr, y = secondArg.basePtr; x <= topArg.endPtr; ++x, ++y)
{
NodeSequence seqX = context.Values[x].Sequence;
NodeSequence seqY = context.Values[y].Sequence;
// Replace with a new sequence that is the union of the two
context.SetValue(context, y, seqY.Union(context, seqX));
}
context.PopFrame();
return this.next;
}
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();
}
internal static void NormalizeSpace(ProcessingContext context)
{
StackFrame argStr = context.TopArg;
StringBuilder builder = new StringBuilder();
while (argStr.basePtr <= argStr.endPtr)
{
char[] whitespace = new char[] { ' ', '\t', '\r', '\n' };
string str = context.PeekString(argStr.basePtr).Trim(whitespace);
bool eatingWhitespace = false;
builder.Length = 0;
for (int i = 0; i < str.Length; ++i)
{
char c = str[i];
if (XPathCharTypes.IsWhitespace(c))
{
if (!eatingWhitespace)
{
builder.Append(' ');
eatingWhitespace = true;
}
}
else
{
builder.Append(c);
eatingWhitespace = false;
}
}
context.SetValue(context, argStr.basePtr, builder.ToString());
argStr.basePtr++;
}
}
internal override void InvokeInternal(ProcessingContext context, int argCount)
{
StackFrame nameArg = context.TopArg;
Message message = context.Processor.ContextMessage;
CorrelationDataMessageProperty data = null;
CorrelationDataMessageProperty.TryGet(message, out data);
while (nameArg.basePtr <= nameArg.endPtr)
{
string value;
if (data == null || !data.TryGetValue(context.PeekString(nameArg.basePtr), out value))
{
value = string.Empty;
}
context.SetValue(context, nameArg.basePtr, value);
nameArg.basePtr++;
}
}
internal static void NumberFloor(ProcessingContext context)
{
StackFrame arg = context.TopArg;
while (arg.basePtr <= arg.endPtr)
{
context.SetValue(context, arg.basePtr, Math.Floor(context.PeekDouble(arg.basePtr)));
arg.basePtr++;
}
}
internal static void NodesetNamespaceUri(ProcessingContext context)
{
StackFrame arg = context.TopArg;
while (arg.basePtr <= arg.endPtr)
{
NodeSequence sequence = context.PeekSequence(arg.basePtr);
context.SetValue(context, arg.basePtr, sequence.Namespace);
arg.basePtr++;
}
}
internal static void NodesetCount(ProcessingContext context)
{
StackFrame arg = context.TopArg;
while (arg.basePtr <= arg.endPtr)
{
context.SetValue(context, arg.basePtr, context.PeekSequence(arg.basePtr).Count);
arg.basePtr++;
}
}
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 override void Eval(ProcessingContext context)
{
Fx.Assert(context != null, "");
StackFrame[] args = new StackFrame[argCount];
for (int i = 0; i < this.argCount; ++i)
{
args[i] = context[i];
}
StringBuilder builder = new StringBuilder();
while (args[0].basePtr <= args[0].endPtr)
{
builder.Length = 0;
for (int i = 0; i < this.argCount; ++i)
{
builder.Append(context.PeekString(args[i].basePtr));
}
context.SetValue(context, args[this.argCount - 1].basePtr, builder.ToString());
for (int i = 0; i < this.argCount; ++i)
{
args[i].basePtr++;
}
}
for (int i = 0; i < this.argCount - 1; ++i)
{
context.PopFrame();
}
}
internal override void InvokeInternal(ProcessingContext context, int argCount)
{
StackFrame spanArg = context.TopArg;
while (spanArg.basePtr <= spanArg.endPtr)
{
string spanStr = context.PeekString(spanArg.basePtr);
context.SetValue(context, spanArg.basePtr, Convert(spanStr));
spanArg.basePtr++;
}
}
internal override Opcode Eval(ProcessingContext context)
{
XPathNavigator nav = context.Processor.ContextNode;
if (nav != null && context.Processor.ContextMessage != null)
{
((SeekableMessageNavigator)nav).Atomize();
}
if (this.argCount == 0)
{
context.PushFrame();
int count = context.IterationCount;
if (count > 0)
{
object ret = this.function.Invoke(this.xsltContext, NullArgs, nav);
switch (this.function.ReturnType)
{
case XPathResultType.String:
context.Push((string)ret, count);
break;
case XPathResultType.Number:
context.Push((double)ret, count);
break;
case XPathResultType.Boolean:
context.Push((bool)ret, count);
break;
case XPathResultType.NodeSet:
NodeSequence seq = context.CreateSequence();
XPathNodeIterator iter = (XPathNodeIterator)ret;
seq.Add(iter);
context.Push(seq, count);
break;
default:
// This should never be reached
throw DiagnosticUtility.ExceptionUtility.ThrowHelperCritical(new QueryProcessingException(QueryProcessingError.Unexpected, SR.GetString(SR.QueryFunctionTypeNotSupported, this.function.ReturnType.ToString())));
}
}
}
else
{
// PERF, [....], see if we can cache these arrays to avoid allocations
object[] xsltArgs = new object[this.argCount];
int iterationCount = context.TopArg.Count;
for (int iteration = 0; iteration < iterationCount; ++iteration)
{
for (int i = 0; i < this.argCount; ++i)
{
StackFrame arg = context[i];
Fx.Assert(iteration < arg.Count, "");
switch (this.function.ArgTypes[i])
{
case XPathResultType.String:
xsltArgs[i] = context.PeekString(arg[iteration]);
break;
case XPathResultType.Number:
xsltArgs[i] = context.PeekDouble(arg[iteration]);
break;
case XPathResultType.Boolean:
xsltArgs[i] = context.PeekBoolean(arg[iteration]);
break;
case XPathResultType.NodeSet:
NodeSequenceIterator iter = new NodeSequenceIterator(context.PeekSequence(arg[iteration]));
xsltArgs[i] = iter;
this.iterList.Add(iter);
break;
default:
// This should never be reached
throw DiagnosticUtility.ExceptionUtility.ThrowHelperCritical(new QueryProcessingException(QueryProcessingError.Unexpected, SR.GetString(SR.QueryFunctionTypeNotSupported, this.function.ArgTypes[i].ToString())));
}
}
object ret = this.function.Invoke(this.xsltContext, xsltArgs, nav);
if (this.iterList != null)
{
for (int i = 0; i < this.iterList.Count; ++i)
{
this.iterList[i].Clear();
}
this.iterList.Clear();
}
switch (this.function.ReturnType)
{
case XPathResultType.String:
context.SetValue(context, context[this.argCount - 1][iteration], (string)ret);
break;
case XPathResultType.Number:
context.SetValue(context, context[this.argCount - 1][iteration], (double)ret);
break;
case XPathResultType.Boolean:
context.SetValue(context, context[this.argCount - 1][iteration], (bool)ret);
break;
case XPathResultType.NodeSet:
NodeSequence seq = context.CreateSequence();
XPathNodeIterator iter = (XPathNodeIterator)ret;
seq.Add(iter);
context.SetValue(context, context[this.argCount - 1][iteration], seq);
break;
default:
// This should never be reached
throw DiagnosticUtility.ExceptionUtility.ThrowHelperCritical(new QueryProcessingException(QueryProcessingError.Unexpected, SR.GetString(SR.QueryFunctionTypeNotSupported, this.function.ReturnType.ToString())));
}
}
for (int i = 0; i < this.argCount - 1; ++i)
{
context.PopFrame();
}
}
return this.next;
}
internal override void InvokeInternal(ProcessingContext context, int argCount)
{
StackFrame actorArg = context.TopArg;
SeekableXPathNavigator nav = context.Processor.ContextNode;
long p = nav.CurrentPosition;
while (actorArg.basePtr <= actorArg.endPtr)
{
string actor = context.PeekString(actorArg.basePtr);
NodeSequence seq = context.CreateSequence();
if (MoveToHeader(nav) && nav.MoveToFirstChild())
{
do
{
// PERF, [....], this will be faster if I cache the envelope namespace to do the
// actor lookup by hand
long pos = nav.CurrentPosition;
string navActor = XPathMessageFunctionActor.ExtractFromNavigator(nav);
nav.CurrentPosition = pos;
if (navActor == actor)
{
seq.Add(nav);
}
} while (nav.MoveToNext());
}
context.SetValue(context, actorArg.basePtr, seq);
actorArg.basePtr++;
}
nav.CurrentPosition = p;
}
internal static void NumberSum(ProcessingContext context)
{
StackFrame arg = context.TopArg;
while (arg.basePtr <= arg.endPtr)
{
NodeSequence sequence = context.PeekSequence(arg.basePtr);
double sum = 0.0;
for (int item = 0; item < sequence.Count; ++item)
{
sum += QueryValueModel.Double(sequence[item].StringValue());
}
context.SetValue(context, arg.basePtr, sum);
arg.basePtr++;
}
}
internal static void Substring(ProcessingContext context)
{
StackFrame arg1 = context.TopArg;
StackFrame arg2 = context.SecondArg;
Fx.Assert(arg1.Count == arg2.Count, "");
while (arg1.basePtr <= arg1.endPtr)
{
string str = context.PeekString(arg1.basePtr);
int startAt = ((int)Math.Round(context.PeekDouble(arg2.basePtr))) - 1;
if (startAt < 0)
{
startAt = 0;
}
context.SetValue(context, arg2.basePtr, (startAt >= str.Length) ? string.Empty : str.Substring(startAt));
arg1.basePtr++;
arg2.basePtr++;
}
context.PopFrame();
}
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 static void StringLength(ProcessingContext context)
{
StackFrame arg = context.TopArg;
while (arg.basePtr <= arg.endPtr)
{
context.SetValue(context, arg.basePtr, context.PeekString(arg.basePtr).Length);
arg.basePtr++;
}
}
internal static void SubstringAfter(ProcessingContext context)
{
StackFrame arg1 = context.TopArg;
StackFrame arg2 = context.SecondArg;
Fx.Assert(arg1.Count == arg2.Count, "");
while (arg1.basePtr <= arg1.endPtr)
{
string str1 = context.PeekString(arg1.basePtr);
string str2 = context.PeekString(arg2.basePtr);
int idx = str1.IndexOf(str2, StringComparison.Ordinal);
context.SetValue(context, arg2.basePtr, idx == -1 ? string.Empty : str1.Substring(idx + str2.Length));
arg1.basePtr++;
arg2.basePtr++;
}
context.PopFrame();
}
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 static void StringStartsWith(ProcessingContext context)
{
StackFrame arg1 = context.TopArg;
StackFrame arg2 = context.SecondArg;
Fx.Assert(arg1.Count == arg2.Count, "");
while (arg1.basePtr <= arg1.endPtr)
{
string leftString = context.PeekString(arg1.basePtr);
string rightString = context.PeekString(arg2.basePtr);
context.SetValue(context, arg2.basePtr, leftString.StartsWith(rightString, StringComparison.Ordinal));
arg1.basePtr++;
arg2.basePtr++;
}
context.PopFrame();
}
