Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
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
2016-05-03 00:07:37 +02:00

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));
}
}
}
}