mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
902 lines
36 KiB
C#
902 lines
36 KiB
C#
//------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//------------------------------------------------------------
|
|
namespace System.ServiceModel.Dispatcher
|
|
{
|
|
using System.Runtime;
|
|
using System.Xml.XPath;
|
|
|
|
// The compiler RECURSIVELY consumes xpath expression trees.
|
|
class XPathCompiler
|
|
{
|
|
QueryCompilerFlags flags;
|
|
int nestingLevel;
|
|
bool pushInitialContext;
|
|
|
|
#if FILTEROPTIMIZER
|
|
FilterOptimizer optimizer;
|
|
|
|
internal XPathCompiler(FilterOptimizer optimizer, QueryCompilerFlags flags)
|
|
{
|
|
this.optimizer = optimizer;
|
|
this.flags = flags;
|
|
this.pushInitialContext = false;
|
|
}
|
|
|
|
internal XPathCompiler(QueryCompilerFlags flags)
|
|
: this(new FilterOptimizer(SelectFunctionTree.standard), flags)
|
|
{
|
|
}
|
|
#else
|
|
internal XPathCompiler(QueryCompilerFlags flags)
|
|
{
|
|
this.flags = flags;
|
|
this.pushInitialContext = false;
|
|
}
|
|
#endif
|
|
|
|
void SetPushInitialContext(bool pushInitial)
|
|
{
|
|
if (pushInitial)
|
|
{
|
|
this.pushInitialContext = pushInitial;
|
|
}
|
|
}
|
|
|
|
// Compiles top level expressions
|
|
internal virtual OpcodeBlock Compile(XPathExpr expr)
|
|
{
|
|
Fx.Assert(null != expr, "");
|
|
|
|
this.nestingLevel = 1;
|
|
this.pushInitialContext = false;
|
|
|
|
XPathExprCompiler exprCompiler = new XPathExprCompiler(this);
|
|
OpcodeBlock mainBlock = exprCompiler.Compile(expr);
|
|
if (this.pushInitialContext)
|
|
{
|
|
OpcodeBlock expandedBlock = new OpcodeBlock();
|
|
expandedBlock.Append(new PushContextNodeOpcode());
|
|
expandedBlock.Append(mainBlock);
|
|
expandedBlock.Append(new PopContextNodes());
|
|
return expandedBlock;
|
|
}
|
|
return mainBlock;
|
|
}
|
|
|
|
// Implemented as a struct because it is cheap to allocate and the Expression compiler is
|
|
// allocated a lot!
|
|
internal struct XPathExprCompiler
|
|
{
|
|
OpcodeBlock codeBlock;
|
|
XPathCompiler compiler;
|
|
|
|
internal XPathExprCompiler(XPathCompiler compiler)
|
|
{
|
|
Fx.Assert(null != compiler, "");
|
|
this.compiler = compiler;
|
|
this.codeBlock = new OpcodeBlock();
|
|
}
|
|
|
|
XPathExprCompiler(XPathExprCompiler xpathCompiler)
|
|
{
|
|
this.compiler = xpathCompiler.compiler;
|
|
this.codeBlock = new OpcodeBlock();
|
|
}
|
|
|
|
internal OpcodeBlock Compile(XPathExpr expr)
|
|
{
|
|
this.codeBlock = new OpcodeBlock(); // struct
|
|
this.CompileExpression(expr);
|
|
return this.codeBlock;
|
|
}
|
|
|
|
OpcodeBlock CompileBlock(XPathExpr expr)
|
|
{
|
|
XPathExprCompiler compiler = new XPathExprCompiler(this);
|
|
return compiler.Compile(expr);
|
|
}
|
|
|
|
void CompileBoolean(XPathExpr expr, bool testValue)
|
|
{
|
|
// Boolean expressions must always have at least 2 sub expressions
|
|
Fx.Assert(expr.SubExprCount > 1, "");
|
|
|
|
if (this.compiler.nestingLevel == 1)
|
|
{
|
|
this.CompileBasicBoolean(expr, testValue);
|
|
return;
|
|
}
|
|
|
|
OpcodeBlock boolBlock = new OpcodeBlock(); // struct
|
|
Opcode blockEnd = new BlockEndOpcode();
|
|
// Set up the result mask
|
|
boolBlock.Append(new PushBooleanOpcode(testValue));
|
|
XPathExprList subExprList = expr.SubExpr;
|
|
XPathExpr subExpr;
|
|
|
|
// the first expression needs the least work..
|
|
subExpr = subExprList[0];
|
|
boolBlock.Append(this.CompileBlock(subExpr));
|
|
if (subExpr.ReturnType != ValueDataType.Boolean)
|
|
{
|
|
boolBlock.Append(new TypecastOpcode(ValueDataType.Boolean));
|
|
}
|
|
boolBlock.Append(new ApplyBooleanOpcode(blockEnd, testValue));
|
|
|
|
// Compile remaining sub-expressions
|
|
for (int i = 1; i < subExprList.Count; ++i)
|
|
{
|
|
subExpr = subExprList[i];
|
|
boolBlock.Append(new StartBooleanOpcode(testValue));
|
|
boolBlock.Append(this.CompileBlock(subExpr));
|
|
// Make sure each sub-expression can produce a boolean result
|
|
if (subExpr.ReturnType != ValueDataType.Boolean)
|
|
{
|
|
boolBlock.Append(new TypecastOpcode(ValueDataType.Boolean));
|
|
}
|
|
boolBlock.Append(new EndBooleanOpcode(blockEnd, testValue));
|
|
}
|
|
boolBlock.Append(blockEnd);
|
|
this.codeBlock.Append(boolBlock);
|
|
}
|
|
|
|
// Compiles expressions at nesting level == 1 -> boolean expressions that can be processed
|
|
// with less complex opcodes because they will never track multiple sequences simultaneously
|
|
void CompileBasicBoolean(XPathExpr expr, bool testValue)
|
|
{
|
|
// Boolean expressions must always have at least 2 sub expressions
|
|
Fx.Assert(expr.SubExprCount > 1, "");
|
|
Fx.Assert(this.compiler.nestingLevel == 1, "");
|
|
|
|
OpcodeBlock boolBlock = new OpcodeBlock(); // struct
|
|
Opcode blockEnd = new BlockEndOpcode();
|
|
XPathExprList subExprList = expr.SubExpr;
|
|
|
|
// Compile sub-expressions
|
|
for (int i = 0; i < subExprList.Count; ++i)
|
|
{
|
|
XPathExpr subExpr = subExprList[i];
|
|
boolBlock.Append(this.CompileBlock(subExpr));
|
|
// Make sure each sub-expression can produce a boolean result
|
|
if (subExpr.ReturnType != ValueDataType.Boolean)
|
|
{
|
|
boolBlock.Append(new TypecastOpcode(ValueDataType.Boolean));
|
|
}
|
|
if (i < (subExprList.Count - 1))
|
|
{
|
|
// No point jumping if this is the last expression
|
|
boolBlock.Append(new JumpIfOpcode(blockEnd, testValue));
|
|
}
|
|
}
|
|
boolBlock.Append(blockEnd);
|
|
this.codeBlock.Append(boolBlock);
|
|
}
|
|
|
|
void CompileExpression(XPathExpr expr)
|
|
{
|
|
Fx.Assert(null != expr, "");
|
|
|
|
switch (expr.Type)
|
|
{
|
|
default:
|
|
this.ThrowError(QueryCompileError.UnsupportedExpression);
|
|
break;
|
|
|
|
case XPathExprType.And:
|
|
this.CompileBoolean(expr, true);
|
|
break;
|
|
|
|
case XPathExprType.Or:
|
|
this.CompileBoolean(expr, false);
|
|
break;
|
|
|
|
case XPathExprType.Relational:
|
|
this.CompileRelational((XPathRelationExpr)expr);
|
|
break;
|
|
|
|
case XPathExprType.Function:
|
|
this.CompileFunction((XPathFunctionExpr)expr);
|
|
break;
|
|
|
|
case XPathExprType.Union:
|
|
{
|
|
XPathConjunctExpr unionExpr = (XPathConjunctExpr)expr;
|
|
this.CompileExpression(unionExpr.Left);
|
|
this.CompileExpression(unionExpr.Right);
|
|
this.codeBlock.Append(new UnionOpcode());
|
|
}
|
|
break;
|
|
|
|
case XPathExprType.RelativePath:
|
|
this.CompileRelativePath(expr, true);
|
|
break;
|
|
|
|
case XPathExprType.LocationPath:
|
|
if (expr.SubExprCount > 0)
|
|
{
|
|
this.CompileLocationPath(expr);
|
|
// Step complete. Transfer results onto the value stack
|
|
this.codeBlock.Append(new PopSequenceToValueStackOpcode());
|
|
}
|
|
break;
|
|
|
|
case XPathExprType.Math:
|
|
this.CompileMath((XPathMathExpr)expr);
|
|
break;
|
|
|
|
case XPathExprType.Number:
|
|
XPathNumberExpr number = (XPathNumberExpr)expr;
|
|
double literal = number.Number;
|
|
if (number.Negate)
|
|
{
|
|
number.Negate = false;
|
|
literal = -literal;
|
|
}
|
|
this.codeBlock.Append(new PushNumberOpcode(literal));
|
|
break;
|
|
|
|
case XPathExprType.String:
|
|
this.codeBlock.Append(new PushStringOpcode(((XPathStringExpr)expr).String));
|
|
break;
|
|
|
|
case XPathExprType.Filter:
|
|
this.CompileFilter(expr);
|
|
if (expr.ReturnType == ValueDataType.Sequence)
|
|
{
|
|
this.codeBlock.Append(new PopSequenceToValueStackOpcode());
|
|
}
|
|
break;
|
|
|
|
case XPathExprType.Path:
|
|
this.CompilePath(expr);
|
|
if (expr.SubExprCount == 0 && expr.ReturnType == ValueDataType.Sequence)
|
|
{
|
|
this.codeBlock.Append(new PopSequenceToValueStackOpcode());
|
|
}
|
|
break;
|
|
|
|
case XPathExprType.XsltFunction:
|
|
this.CompileXsltFunction((XPathXsltFunctionExpr)expr);
|
|
break;
|
|
|
|
case XPathExprType.XsltVariable:
|
|
this.CompileXsltVariable((XPathXsltVariableExpr)expr);
|
|
break;
|
|
}
|
|
|
|
NegateIfRequired(expr);
|
|
}
|
|
|
|
void CompileFilter(XPathExpr expr)
|
|
{
|
|
Fx.Assert(XPathExprType.Filter == expr.Type, "");
|
|
// The filter expression has two components - the expression and its predicate
|
|
// It may have an optional relative path following it
|
|
//Debug.Assert(expr.SubExprCount <= 3);
|
|
XPathExprList subExpr = expr.SubExpr;
|
|
|
|
XPathExpr filterExpr = subExpr[0];
|
|
if (subExpr.Count > 1 && ValueDataType.Sequence != filterExpr.ReturnType)
|
|
{
|
|
this.ThrowError(QueryCompileError.InvalidExpression);
|
|
}
|
|
// The filter expression will return a sequence and push it onto the value stack
|
|
// Transfer it back to the sequence stack, so we can keep working on it
|
|
this.CompileExpression(filterExpr);
|
|
if (filterExpr.ReturnType == ValueDataType.Sequence)
|
|
{
|
|
if (!IsSpecialInternalFunction(filterExpr) && expr.SubExprCount > 1)
|
|
{
|
|
// Flatten the sequence and move it to the sequence stack
|
|
this.codeBlock.Append(new MergeOpcode());
|
|
this.codeBlock.Append(new PopSequenceToSequenceStackOpcode());
|
|
}
|
|
else if (IsSpecialInternalFunction(filterExpr) && expr.SubExprCount > 1)
|
|
{
|
|
this.codeBlock.DetachLast();
|
|
}
|
|
|
|
// Now, apply the predicates
|
|
this.compiler.nestingLevel++;
|
|
if (this.compiler.nestingLevel > 3) // throw if we find something deepter than [ [ ] ]
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new QueryCompileException(QueryCompileError.PredicateNestingTooDeep));
|
|
}
|
|
for (int i = 1; i < expr.SubExprCount; ++i)
|
|
{
|
|
this.CompilePredicate(subExpr[i]);
|
|
}
|
|
this.compiler.nestingLevel--;
|
|
}
|
|
}
|
|
|
|
bool IsSpecialInternalFunction(XPathExpr expr)
|
|
{
|
|
if (expr.Type != XPathExprType.XsltFunction)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
XPathMessageFunction func = ((XPathXsltFunctionExpr)expr).Function as XPathMessageFunction;
|
|
if (func != null)
|
|
{
|
|
return func.ReturnType == XPathResultType.NodeSet && func.Maxargs == 0;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void CompileFunction(XPathFunctionExpr expr)
|
|
{
|
|
// In some scenarios, some functions are handled in a special way
|
|
if (this.CompileFunctionSpecial(expr))
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Generic function compilation
|
|
QueryFunction function = expr.Function;
|
|
// Compile each argument expression first, introducing a typecast where appropriate
|
|
// Arguments are pushed C style - right to left
|
|
if (expr.SubExprCount > 0)
|
|
{
|
|
XPathExprList paramList = expr.SubExpr;
|
|
for (int i = paramList.Count - 1; i >= 0; --i)
|
|
{
|
|
this.CompileFunctionParam(function, expr.SubExpr, i);
|
|
}
|
|
}
|
|
this.codeBlock.Append(new FunctionCallOpcode(function));
|
|
if (1 == this.compiler.nestingLevel && function.TestFlag(QueryFunctionFlag.UsesContextNode))
|
|
{
|
|
this.compiler.SetPushInitialContext(true);
|
|
}
|
|
}
|
|
|
|
void CompileFunctionParam(QueryFunction function, XPathExprList paramList, int index)
|
|
{
|
|
XPathExpr param = paramList[index];
|
|
this.CompileExpression(param);
|
|
if (ValueDataType.None != function.ParamTypes[index])
|
|
{
|
|
if (param.ReturnType != function.ParamTypes[index])
|
|
{
|
|
if (function.ParamTypes[index] == ValueDataType.Sequence)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new QueryCompileException(QueryCompileError.InvalidTypeConversion));
|
|
}
|
|
|
|
this.CompileTypecast(function.ParamTypes[index]);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Some functions are compiled with special opcodes to optimize perf in special situations
|
|
// 1. starts-with(string, literal)
|
|
bool CompileFunctionSpecial(XPathFunctionExpr expr)
|
|
{
|
|
XPathFunction function = expr.Function as XPathFunction;
|
|
if (null != function)
|
|
{
|
|
if (XPathFunctionID.StartsWith == function.ID)
|
|
{
|
|
// Does the 2nd parameter start with a string literal? Use a special opcode to handle those..
|
|
Fx.Assert(expr.SubExprCount == 2, "");
|
|
if (XPathExprType.String == expr.SubExpr[1].Type)
|
|
{
|
|
this.CompileFunctionParam(function, expr.SubExpr, 0);
|
|
this.codeBlock.Append(new StringPrefixOpcode(((XPathStringExpr)expr.SubExpr[1]).String));
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void CompileLiteralRelation(XPathRelationExpr expr)
|
|
{
|
|
XPathLiteralExpr left = (XPathLiteralExpr)expr.Left;
|
|
XPathLiteralExpr right = (XPathLiteralExpr)expr.Right;
|
|
|
|
bool result = QueryValueModel.CompileTimeCompare(left.Literal, right.Literal, expr.Op);
|
|
this.codeBlock.Append(new PushBooleanOpcode(result));
|
|
}
|
|
|
|
void CompileLiteralOrdinal(XPathExpr expr)
|
|
{
|
|
int ordinal = 0;
|
|
try
|
|
{
|
|
XPathNumberExpr numExpr = (XPathNumberExpr)expr;
|
|
ordinal = Convert.ToInt32(numExpr.Number);
|
|
if (numExpr.Negate)
|
|
{
|
|
ordinal = -ordinal;
|
|
numExpr.Negate = false;
|
|
}
|
|
if (ordinal < 1)
|
|
{
|
|
this.ThrowError(QueryCompileError.InvalidOrdinal);
|
|
}
|
|
}
|
|
catch (OverflowException)
|
|
{
|
|
this.ThrowError(QueryCompileError.InvalidOrdinal);
|
|
}
|
|
|
|
if (0 != (this.compiler.flags & QueryCompilerFlags.InverseQuery))
|
|
{
|
|
this.codeBlock.Append(new PushContextPositionOpcode());
|
|
this.codeBlock.Append(new NumberEqualsOpcode(ordinal));
|
|
}
|
|
else
|
|
{
|
|
this.codeBlock.Append(new LiteralOrdinalOpcode(ordinal));
|
|
}
|
|
}
|
|
|
|
void CompileLocationPath(XPathExpr expr)
|
|
{
|
|
Fx.Assert(expr.SubExprCount > 0, "");
|
|
|
|
XPathStepExpr firstStep = (XPathStepExpr)expr.SubExpr[0];
|
|
|
|
this.CompileSteps(expr.SubExpr);
|
|
|
|
if (1 == this.compiler.nestingLevel)
|
|
{
|
|
this.compiler.SetPushInitialContext(firstStep.SelectDesc.Type != QueryNodeType.Root);
|
|
}
|
|
}
|
|
|
|
void CompileMath(XPathMathExpr mathExpr)
|
|
{
|
|
// are we doing math on two literal numbers? If so, do it at compile time
|
|
if (XPathExprType.Number == mathExpr.Right.Type && XPathExprType.Number == mathExpr.Left.Type)
|
|
{
|
|
double left = ((XPathNumberExpr)mathExpr.Left).Number;
|
|
if (((XPathNumberExpr)mathExpr.Left).Negate)
|
|
{
|
|
((XPathNumberExpr)mathExpr.Left).Negate = false;
|
|
left = -left;
|
|
}
|
|
double right = ((XPathNumberExpr)mathExpr.Right).Number;
|
|
if (((XPathNumberExpr)mathExpr.Right).Negate)
|
|
{
|
|
((XPathNumberExpr)mathExpr.Right).Negate = false;
|
|
right = -right;
|
|
}
|
|
switch (mathExpr.Op)
|
|
{
|
|
case MathOperator.Div:
|
|
left /= right;
|
|
break;
|
|
case MathOperator.Minus:
|
|
left -= right;
|
|
break;
|
|
case MathOperator.Mod:
|
|
left %= right;
|
|
break;
|
|
case MathOperator.Multiply:
|
|
left *= right;
|
|
break;
|
|
case MathOperator.Plus:
|
|
left += right;
|
|
break;
|
|
}
|
|
this.codeBlock.Append(new PushNumberOpcode(left));
|
|
return;
|
|
}
|
|
|
|
// Arguments are pushed C style - right to left
|
|
this.CompileExpression(mathExpr.Right);
|
|
if (ValueDataType.Double != mathExpr.Right.ReturnType)
|
|
{
|
|
this.CompileTypecast(ValueDataType.Double);
|
|
}
|
|
this.CompileExpression(mathExpr.Left);
|
|
if (ValueDataType.Double != mathExpr.Left.ReturnType)
|
|
{
|
|
this.CompileTypecast(ValueDataType.Double);
|
|
}
|
|
this.codeBlock.Append(this.CreateMathOpcode(mathExpr.Op));
|
|
}
|
|
|
|
void CompileNumberLiteralEquality(XPathRelationExpr expr)
|
|
{
|
|
Fx.Assert(expr.Op == RelationOperator.Eq, "");
|
|
|
|
bool leftNumber = (XPathExprType.Number == expr.Left.Type);
|
|
bool rightNumber = (XPathExprType.Number == expr.Right.Type);
|
|
|
|
Fx.Assert(leftNumber || rightNumber, "");
|
|
Fx.Assert(!(leftNumber && rightNumber), "");
|
|
|
|
this.CompileExpression(leftNumber ? expr.Right : expr.Left);
|
|
XPathNumberExpr litExpr = leftNumber ? (XPathNumberExpr)expr.Left : (XPathNumberExpr)expr.Right;
|
|
double literal = litExpr.Number;
|
|
if (litExpr.Negate)
|
|
{
|
|
litExpr.Negate = false;
|
|
literal = -literal;
|
|
}
|
|
this.codeBlock.Append(new NumberEqualsOpcode(literal));
|
|
}
|
|
|
|
void CompileNumberRelation(XPathRelationExpr expr)
|
|
{
|
|
if (expr.Op == RelationOperator.Eq)
|
|
{
|
|
this.CompileNumberLiteralEquality(expr);
|
|
return;
|
|
}
|
|
|
|
bool leftNumber = (XPathExprType.Number == expr.Left.Type);
|
|
bool rightNumber = (XPathExprType.Number == expr.Right.Type);
|
|
Fx.Assert(leftNumber || rightNumber, "");
|
|
Fx.Assert(!(leftNumber && rightNumber), "");
|
|
|
|
this.CompileExpression(leftNumber ? expr.Right : expr.Left);
|
|
XPathNumberExpr litExpr = leftNumber ? (XPathNumberExpr)expr.Left : (XPathNumberExpr)expr.Right;
|
|
double literal = litExpr.Number;
|
|
if (litExpr.Negate)
|
|
{
|
|
litExpr.Negate = false;
|
|
literal = -literal;
|
|
}
|
|
|
|
// To maximize code branch commonality, we canonacalize the relation expressions so that the non-literal
|
|
// is always to the left and the literal to the right. If this makes us swap expressions, we must also flip
|
|
// relation operators appropriately.
|
|
if (leftNumber)
|
|
{
|
|
// Flip operators
|
|
switch (expr.Op)
|
|
{
|
|
case RelationOperator.Gt:
|
|
expr.Op = RelationOperator.Lt;
|
|
break;
|
|
case RelationOperator.Ge:
|
|
expr.Op = RelationOperator.Le;
|
|
break;
|
|
case RelationOperator.Lt:
|
|
expr.Op = RelationOperator.Gt;
|
|
break;
|
|
case RelationOperator.Le:
|
|
expr.Op = RelationOperator.Ge;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (0 != (this.compiler.flags & QueryCompilerFlags.InverseQuery))
|
|
{
|
|
this.codeBlock.Append(new NumberIntervalOpcode(literal, expr.Op));
|
|
}
|
|
else
|
|
{
|
|
this.codeBlock.Append(new NumberRelationOpcode(literal, expr.Op));
|
|
}
|
|
}
|
|
|
|
void CompilePath(XPathExpr expr)
|
|
{
|
|
Fx.Assert(expr.SubExprCount == 2 || expr.SubExprCount == 3, "");
|
|
|
|
if (expr.Type == XPathExprType.Filter)
|
|
{
|
|
this.CompileFilter(expr.SubExpr[0]);
|
|
}
|
|
else
|
|
{
|
|
this.CompileExpression(expr.SubExpr[0]);
|
|
if (expr.SubExpr[0].ReturnType == ValueDataType.Sequence)
|
|
{
|
|
if (IsSpecialInternalFunction(expr.SubExpr[0]))
|
|
{
|
|
this.codeBlock.DetachLast();
|
|
}
|
|
else
|
|
{
|
|
this.codeBlock.Append(new MergeOpcode());
|
|
this.codeBlock.Append(new PopSequenceToSequenceStackOpcode());
|
|
}
|
|
}
|
|
}
|
|
|
|
if (expr.SubExprCount == 2)
|
|
{
|
|
this.CompileRelativePath(expr.SubExpr[1], false);
|
|
}
|
|
else if (expr.SubExprCount == 3)
|
|
{
|
|
// Compile the step
|
|
XPathExpr e = expr.SubExpr[1];
|
|
Fx.Assert(XPathExprType.PathStep == e.Type, "");
|
|
|
|
XPathStepExpr step = (XPathStepExpr)e;
|
|
Fx.Assert(QueryNodeType.Root != step.SelectDesc.Type, "");
|
|
|
|
if (!step.SelectDesc.Axis.IsSupported())
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new QueryCompileException(QueryCompileError.UnsupportedAxis));
|
|
}
|
|
|
|
this.codeBlock.Append(new SelectOpcode(step.SelectDesc));
|
|
|
|
// The step may have predicates..
|
|
if (step.SubExprCount > 0)
|
|
{
|
|
this.compiler.nestingLevel++;
|
|
if (this.compiler.nestingLevel > 3) // throw if we find something deepter than [ [ ] ]
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new QueryCompileException(QueryCompileError.PredicateNestingTooDeep));
|
|
}
|
|
this.CompilePredicates(step.SubExpr);
|
|
this.compiler.nestingLevel--;
|
|
}
|
|
|
|
// Compile the relative path
|
|
this.CompileRelativePath(expr.SubExpr[2], false);
|
|
}
|
|
}
|
|
|
|
void CompilePredicate(XPathExpr expr)
|
|
{
|
|
// If the expression does not return a boolean, introduce a typecast
|
|
// If the predicate expression is a standalone number literal, interpret it as a literal
|
|
if (expr.IsLiteral && XPathExprType.Number == expr.Type)
|
|
{
|
|
this.CompileLiteralOrdinal(expr);
|
|
}
|
|
else
|
|
{
|
|
this.CompileExpression(expr);
|
|
if (expr.ReturnType == ValueDataType.Double)
|
|
{
|
|
this.codeBlock.Append(new OrdinalOpcode());
|
|
}
|
|
else if (expr.ReturnType != ValueDataType.Boolean)
|
|
{
|
|
this.CompileTypecast(ValueDataType.Boolean);
|
|
}
|
|
}
|
|
// Apply the results of the predicate on the context sequence
|
|
this.codeBlock.Append(new ApplyFilterOpcode());
|
|
}
|
|
|
|
void CompilePredicates(XPathExprList exprList)
|
|
{
|
|
// Compile each predicate expression first
|
|
for (int i = 0; i < exprList.Count; ++i)
|
|
{
|
|
this.CompilePredicate(exprList[i]);
|
|
}
|
|
}
|
|
|
|
void CompileRelational(XPathRelationExpr expr)
|
|
{
|
|
// Are we comparing two literals?
|
|
if (expr.Left.IsLiteral && expr.Right.IsLiteral)
|
|
{
|
|
// Do the comparison at compile time
|
|
this.CompileLiteralRelation(expr);
|
|
return;
|
|
}
|
|
|
|
// != is not optimized in M5
|
|
if (expr.Op != RelationOperator.Ne)
|
|
{
|
|
// Number relations are handled in a special way
|
|
if (XPathExprType.Number == expr.Left.Type || XPathExprType.Number == expr.Right.Type)
|
|
{
|
|
this.CompileNumberRelation(expr);
|
|
return;
|
|
}
|
|
|
|
// Equality tests with string literals are handled in a special way
|
|
if (expr.Op == RelationOperator.Eq && (XPathExprType.String == expr.Left.Type || XPathExprType.String == expr.Right.Type))
|
|
{
|
|
this.CompileStringLiteralEquality(expr);
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Can't optimize. Use a general purpose relation opcode
|
|
this.CompileExpression(expr.Left);
|
|
this.CompileExpression(expr.Right);
|
|
this.codeBlock.Append(new RelationOpcode(expr.Op));
|
|
}
|
|
|
|
void CompileRelativePath(XPathExpr expr, bool start)
|
|
{
|
|
Fx.Assert(XPathExprType.RelativePath == expr.Type, "");
|
|
this.CompileSteps(expr.SubExpr, start);
|
|
// Step complete. Transfer results onto the value stack
|
|
this.codeBlock.Append(new PopSequenceToValueStackOpcode());
|
|
}
|
|
|
|
void CompileStringLiteralEquality(XPathRelationExpr expr)
|
|
{
|
|
Fx.Assert(expr.Op == RelationOperator.Eq, "");
|
|
|
|
bool leftString = (XPathExprType.String == expr.Left.Type);
|
|
bool rightString = (XPathExprType.String == expr.Right.Type);
|
|
|
|
Fx.Assert(leftString || rightString, "");
|
|
Fx.Assert(!(leftString && rightString), "");
|
|
|
|
this.CompileExpression(leftString ? expr.Right : expr.Left);
|
|
string literal = leftString ? ((XPathStringExpr)expr.Left).String : ((XPathStringExpr)expr.Right).String;
|
|
this.codeBlock.Append(new StringEqualsOpcode(literal));
|
|
}
|
|
|
|
void CompileSteps(XPathExprList steps)
|
|
{
|
|
CompileSteps(steps, true);
|
|
}
|
|
|
|
void CompileSteps(XPathExprList steps, bool start)
|
|
{
|
|
for (int i = 0; i < steps.Count; ++i)
|
|
{
|
|
Fx.Assert(XPathExprType.PathStep == steps[i].Type, "");
|
|
XPathStepExpr step = (XPathStepExpr)steps[i];
|
|
if (!step.SelectDesc.Axis.IsSupported())
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new QueryCompileException(QueryCompileError.UnsupportedAxis));
|
|
}
|
|
Opcode stepOpcode = null;
|
|
if (start && 0 == i)
|
|
{
|
|
// First steps
|
|
// Is this an absolute path? We have an absolute path if the first step selects the root
|
|
if (QueryNodeType.Root == step.SelectDesc.Type)
|
|
{
|
|
stepOpcode = new SelectRootOpcode();
|
|
}
|
|
else
|
|
{
|
|
stepOpcode = new InitialSelectOpcode(step.SelectDesc);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Fx.Assert(QueryNodeType.Root != step.SelectDesc.Type, "");
|
|
stepOpcode = new SelectOpcode(step.SelectDesc);
|
|
}
|
|
this.codeBlock.Append(stepOpcode);
|
|
// The step may have predicates..
|
|
if (step.SubExprCount > 0)
|
|
{
|
|
this.compiler.nestingLevel++;
|
|
if (this.compiler.nestingLevel > 3) // throw if we find something deepter than [ [ ] ]
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new QueryCompileException(QueryCompileError.PredicateNestingTooDeep));
|
|
}
|
|
this.CompilePredicates(step.SubExpr);
|
|
this.compiler.nestingLevel--;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CompileTypecast(ValueDataType destType)
|
|
{
|
|
Fx.Assert(ValueDataType.None != destType, "");
|
|
this.codeBlock.Append(new TypecastOpcode(destType));
|
|
}
|
|
|
|
void CompileXsltFunction(XPathXsltFunctionExpr expr)
|
|
{
|
|
// Compile each argument expression first, introducing a typecast where appropriate
|
|
// Arguments are pushed C style - right to left
|
|
if (expr.SubExprCount > 0)
|
|
{
|
|
XPathExprList paramList = expr.SubExpr;
|
|
for (int i = paramList.Count - 1; i >= 0; --i)
|
|
{
|
|
XPathExpr param = paramList[i];
|
|
this.CompileExpression(param);
|
|
ValueDataType paramType = XPathXsltFunctionExpr.ConvertTypeFromXslt(expr.Function.ArgTypes[i]);
|
|
if (ValueDataType.None != paramType)
|
|
{
|
|
if (param.ReturnType != paramType)
|
|
{
|
|
this.CompileTypecast(paramType);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (expr.Function is XPathMessageFunction)
|
|
{
|
|
this.codeBlock.Append(new XPathMessageFunctionCallOpcode((XPathMessageFunction)expr.Function, expr.SubExprCount));
|
|
if (IsSpecialInternalFunction(expr))
|
|
{
|
|
this.codeBlock.Append(new PopSequenceToValueStackOpcode());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this.codeBlock.Append(new XsltFunctionCallOpcode(expr.Context, expr.Function, expr.SubExprCount));
|
|
}
|
|
}
|
|
|
|
void CompileXsltVariable(XPathXsltVariableExpr expr)
|
|
{
|
|
#if NO
|
|
// Remove this block if we never decide to use variables in an XPathMessageContext
|
|
// It is here in case we decide to
|
|
if (expr.Variable is XPathMessageVariable)
|
|
{
|
|
this.codeBlock.Append(new PushXPathMessageVariableOpcode((XPathMessageVariable)expr.Variable));
|
|
}
|
|
else
|
|
{
|
|
this.codeBlock.Append(new PushXsltVariableOpcode(expr.Context, expr.Variable));
|
|
}
|
|
#endif
|
|
this.codeBlock.Append(new PushXsltVariableOpcode(expr.Context, expr.Variable));
|
|
}
|
|
|
|
MathOpcode CreateMathOpcode(MathOperator op)
|
|
{
|
|
MathOpcode opcode = null;
|
|
switch (op)
|
|
{
|
|
case MathOperator.None:
|
|
Fx.Assert("");
|
|
break;
|
|
|
|
case MathOperator.Plus:
|
|
opcode = new PlusOpcode();
|
|
break;
|
|
case MathOperator.Minus:
|
|
opcode = new MinusOpcode();
|
|
break;
|
|
case MathOperator.Div:
|
|
opcode = new DivideOpcode();
|
|
break;
|
|
case MathOperator.Multiply:
|
|
opcode = new MultiplyOpcode();
|
|
break;
|
|
case MathOperator.Mod:
|
|
opcode = new ModulusOpcode();
|
|
break;
|
|
case MathOperator.Negate:
|
|
opcode = new NegateOpcode();
|
|
break;
|
|
}
|
|
|
|
return opcode;
|
|
}
|
|
|
|
void NegateIfRequired(XPathExpr expr)
|
|
{
|
|
// We can combine these two since the flags they examine are set in exactly one (the same) place.
|
|
TypecastIfRequired(expr);
|
|
if (expr.Negate)
|
|
{
|
|
expr.Negate = false;
|
|
this.codeBlock.Append(new NegateOpcode());
|
|
}
|
|
}
|
|
|
|
void TypecastIfRequired(XPathExpr expr)
|
|
{
|
|
if (expr.TypecastRequired)
|
|
{
|
|
expr.TypecastRequired = false;
|
|
CompileTypecast(expr.ReturnType);
|
|
}
|
|
}
|
|
|
|
void ThrowError(QueryCompileError error)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new QueryCompileException(error));
|
|
}
|
|
}
|
|
}
|
|
}
|