private bool ParseRelativePath(XPathExprList path)
        {
            XPathStepExpr expr = this.ParseStep();

            if (expr == null)
            {
                return(false);
            }
            path.Add(expr);
            while (true)
            {
                if (this.NextToken(XPathTokenID.Slash) != null)
                {
                    expr = this.ParseStep();
                }
                else
                {
                    if (this.NextToken(XPathTokenID.DblSlash) == null)
                    {
                        return(true);
                    }
                    expr = new XPathStepExpr(new NodeSelectCriteria(QueryAxisType.DescendantOrSelf, NodeQName.Empty, QueryNodeType.All));
                    path.Add(expr);
                    expr = this.ParseStep();
                }
                if (expr == null)
                {
                    this.ThrowError(QueryCompileError.InvalidLocationPath);
                }
                path.Add(expr);
            }
        }
Beispiel #2
0
            private void CompileLocationPath(XPathExpr expr)
            {
                XPathStepExpr expr2 = (XPathStepExpr)expr.SubExpr[0];

                this.CompileSteps(expr.SubExpr);
                if (1 == this.compiler.nestingLevel)
                {
                    this.compiler.SetPushInitialContext(expr2.SelectDesc.Type != QueryNodeType.Root);
                }
            }
Beispiel #3
0
            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);
                }
            }
Beispiel #4
0
 private void CompilePath(XPathExpr expr)
 {
     if (expr.Type == XPathExprType.Filter)
     {
         this.CompileFilter(expr.SubExpr[0]);
     }
     else
     {
         this.CompileExpression(expr.SubExpr[0]);
         if (expr.SubExpr[0].ReturnType == ValueDataType.Sequence)
         {
             if (this.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)
     {
         XPathExpr     expr2 = expr.SubExpr[1];
         XPathStepExpr expr3 = (XPathStepExpr)expr2;
         if (!expr3.SelectDesc.Axis.IsSupported())
         {
             throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new QueryCompileException(QueryCompileError.UnsupportedAxis));
         }
         this.codeBlock.Append(new SelectOpcode(expr3.SelectDesc));
         if (expr3.SubExprCount > 0)
         {
             this.compiler.nestingLevel++;
             if (this.compiler.nestingLevel > 3)
             {
                 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new QueryCompileException(QueryCompileError.PredicateNestingTooDeep));
             }
             this.CompilePredicates(expr3.SubExpr);
             this.compiler.nestingLevel--;
         }
         this.CompileRelativePath(expr.SubExpr[2], false);
     }
 }
Beispiel #5
0
 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--;
         }
     }
 }
Beispiel #6
0
        bool ParseRelativePath(XPathExprList path)
        {
            Fx.Assert(null != path, "");

            XPathStepExpr step = this.ParseStep();

            if (null == step)
            {
                return(false);
            }

            path.Add(step);
            while (true)
            {
                if (null != this.NextToken(XPathTokenID.Slash))
                {
                    step = this.ParseStep();
                }
                else if (null != this.NextToken(XPathTokenID.DblSlash))
                {
                    step = new XPathStepExpr(new NodeSelectCriteria(QueryAxisType.DescendantOrSelf, NodeQName.Empty, QueryNodeType.All));
                    path.Add(step);
                    step = this.ParseStep();
                }
                else
                {
                    break;
                }

                if (null == step)
                {
                    this.ThrowError(QueryCompileError.InvalidLocationPath);
                }

                path.Add(step);
            }

            return(true);
        }
Beispiel #7
0
 private void CompileSteps(XPathExprList steps, bool start)
 {
     for (int i = 0; i < steps.Count; i++)
     {
         XPathStepExpr expr = (XPathStepExpr)steps[i];
         if (!expr.SelectDesc.Axis.IsSupported())
         {
             throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new QueryCompileException(QueryCompileError.UnsupportedAxis));
         }
         Opcode opcode = null;
         if (start && (i == 0))
         {
             if (QueryNodeType.Root == expr.SelectDesc.Type)
             {
                 opcode = new SelectRootOpcode();
             }
             else
             {
                 opcode = new InitialSelectOpcode(expr.SelectDesc);
             }
         }
         else
         {
             opcode = new SelectOpcode(expr.SelectDesc);
         }
         this.codeBlock.Append(opcode);
         if (expr.SubExprCount > 0)
         {
             this.compiler.nestingLevel++;
             if (this.compiler.nestingLevel > 3)
             {
                 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new QueryCompileException(QueryCompileError.PredicateNestingTooDeep));
             }
             this.CompilePredicates(expr.SubExpr);
             this.compiler.nestingLevel--;
         }
     }
 }
        bool ParseRelativePath(XPathExprList path)
        {
            Fx.Assert(null != path, "");

            XPathStepExpr step = this.ParseStep();

            if (null == step)
            {
                return false;
            }

            path.Add(step);
            while (true)
            {
                if (null != this.NextToken(XPathTokenID.Slash))
                {
                    step = this.ParseStep();
                }
                else if (null != this.NextToken(XPathTokenID.DblSlash))
                {
                    step = new XPathStepExpr(new NodeSelectCriteria(QueryAxisType.DescendantOrSelf, NodeQName.Empty, QueryNodeType.All));
                    path.Add(step);
                    step = this.ParseStep();
                }
                else
                {
                    break;
                }

                if (null == step)
                {
                    this.ThrowError(QueryCompileError.InvalidLocationPath);
                }

                path.Add(step);
            }

            return true;
        }
Beispiel #9
0
            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);
                }
            }
 private bool ParseRelativePath(XPathExprList path)
 {
     XPathStepExpr expr = this.ParseStep();
     if (expr == null)
     {
         return false;
     }
     path.Add(expr);
     while (true)
     {
         if (this.NextToken(XPathTokenID.Slash) != null)
         {
             expr = this.ParseStep();
         }
         else
         {
             if (this.NextToken(XPathTokenID.DblSlash) == null)
             {
                 return true;
             }
             expr = new XPathStepExpr(new NodeSelectCriteria(QueryAxisType.DescendantOrSelf, NodeQName.Empty, QueryNodeType.All));
             path.Add(expr);
             expr = this.ParseStep();
         }
         if (expr == null)
         {
             this.ThrowError(QueryCompileError.InvalidLocationPath);
         }
         path.Add(expr);
     }
 }