mono/mcs/class/referencesource/System.ServiceModel/System/ServiceModel/Dispatcher/XPathCompiler.cs

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