Exemple #1
0
        internal static OpcodeBlock CompileForInternalEngine(string xpath, XmlNamespaceManager nsManager, QueryCompilerFlags flags, IFunctionLibrary[] functionLibs, out ValueDataType returnType)
        {
            OpcodeBlock codeBlock;

            returnType = ValueDataType.None;
            if (0 == xpath.Length)
            {
                // 0 length XPaths always match
                codeBlock = new OpcodeBlock();
                codeBlock.Append(new PushBooleanOpcode(true)); // Always match by pushing true on the eval stack
            }
            else
            {
                // Try to parse the xpath. Bind to default function libraries
                // The parser returns an expression tree
                XPathParser parser    = new XPathParser(xpath, nsManager, functionLibs);
                XPathExpr   parseTree = parser.Parse();

                if (null == parseTree)
                {
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new QueryCompileException(QueryCompileError.CouldNotParseExpression));
                }

                returnType = parseTree.ReturnType;

                // Compile the expression tree
                XPathCompiler compiler = new XPathCompiler(flags);

                codeBlock = compiler.Compile(parseTree);
            }

            return(codeBlock);
        }
        internal static OpcodeBlock CompileForInternalEngine(string xpath, XmlNamespaceManager nsManager, QueryCompilerFlags flags, IFunctionLibrary[] functionLibs, out ValueDataType returnType)
        {
            returnType = ValueDataType.None;
            if (xpath.Length == 0)
            {
                OpcodeBlock block = new OpcodeBlock();
                block.Append(new PushBooleanOpcode(true));
                return(block);
            }
            XPathExpr expr = new XPathParser(xpath, nsManager, functionLibs).Parse();

            if (expr == null)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new QueryCompileException(QueryCompileError.CouldNotParseExpression));
            }
            returnType = expr.ReturnType;
            XPathCompiler compiler = new XPathCompiler(flags);

            return(compiler.Compile(expr));
        }
 private XPathTokenID GetNodeTypeOrFunction(XPathParser.QName qname)
 {
     XPathTokenID namedType = this.GetNamedType(qname.Name);
     if ((namedType & XPathTokenID.NodeType) == XPathTokenID.Unknown)
     {
         return XPathTokenID.Function;
     }
     if (qname.Prefix.Length > 0)
     {
         this.ThrowError(QueryCompileError.InvalidNodeType, qname.Prefix + ":" + qname.Name);
     }
     return namedType;
 }
 private XPathTokenID GetNamedOperator(XPathParser.QName qname)
 {
     if (qname.Prefix.Length != 0)
     {
         this.ThrowError(QueryCompileError.InvalidOperatorName, qname.Prefix + ":" + qname.Name);
     }
     XPathTokenID namedType = this.GetNamedType(qname.Name);
     if (this.resolveKeywords && ((namedType & XPathTokenID.NamedOperator) == XPathTokenID.Unknown))
     {
         this.ThrowError(QueryCompileError.UnsupportedOperator, this.previousID.ToString() + "->" + qname.Name);
     }
     return namedType;
 }
 private XPathTokenID GetAxisName(XPathParser.QName qname)
 {
     if (qname.Prefix.Length != 0)
     {
         this.ThrowError(QueryCompileError.InvalidAxisSpecifier, qname.Prefix + ":" + qname.Name);
     }
     XPathTokenID namedType = this.GetNamedType(qname.Name);
     if (this.resolveKeywords && ((namedType & XPathTokenID.Axis) == XPathTokenID.Unknown))
     {
         this.ThrowError(QueryCompileError.UnsupportedAxis, qname.Name);
     }
     return namedType;
 }
        private XPathTokenID GetNamedOperator(XPathParser.QName qname)
        {
            // Named operators can't have prefixes
            if (qname.Prefix.Length != 0)
            {
                ThrowError(QueryCompileError.InvalidOperatorName, qname.Prefix + ":" + qname.Name);
            }

            // Make sure the type is 'NamedOperator'
            XPathTokenID id = GetNamedType(qname.Name);
            if (this.resolveKeywords && (id & XPathTokenID.NamedOperator) == 0)
            {
                ThrowError(QueryCompileError.UnsupportedOperator, this.previousID.ToString() + "->" + qname.Name);
            }

            return id;
        }
 internal void Set(XPathTokenID id, XPathParser.QName qname)
 {
     this.Set(id, qname.Name);
     this.prefix = qname.Prefix;
 }
        private XPathTokenID GetNodeTypeOrFunction(XPathParser.QName qname)
        {
            XPathTokenID id = GetNamedType(qname.Name);

            // If it's not a node type, it's lexed as a function
            if ((id & XPathTokenID.NodeType) == 0)
            {
                id = XPathTokenID.Function;
            }
            else if (qname.Prefix.Length > 0)
            {
                // Node types don't have prefixes
                ThrowError(QueryCompileError.InvalidNodeType, qname.Prefix + ":" + qname.Name);
            }

            return id;
        }
        private XPathTokenID GetAxisName(XPathParser.QName qname)
        {
            // Axes can't have prefixes
            if (qname.Prefix.Length != 0)
            {
                ThrowError(QueryCompileError.InvalidAxisSpecifier, qname.Prefix + ":" + qname.Name);
            }

            // Make sure the type is 'Axis'
            XPathTokenID id = GetNamedType(qname.Name);
            if (this.resolveKeywords && (id & XPathTokenID.Axis) == 0)
            {
                ThrowError(QueryCompileError.UnsupportedAxis, qname.Name);
            }

            return id;
        }