private XPathExprList ParseAbsolutePath() { XPathExprList path = null; XPathToken token = this.NextToken(); if (token != null) { XPathTokenID tokenID = token.TokenID; if (tokenID == XPathTokenID.Slash) { path = new XPathExprList(); path.Add(new XPathStepExpr(new NodeSelectCriteria(QueryAxisType.Child, NodeQName.Empty, QueryNodeType.Root))); } else if (tokenID == XPathTokenID.DblSlash) { path = new XPathExprList(); path.Add(new XPathStepExpr(new NodeSelectCriteria(QueryAxisType.Child, NodeQName.Empty, QueryNodeType.Root))); path.Add(new XPathStepExpr(new NodeSelectCriteria(QueryAxisType.DescendantOrSelf, NodeQName.Empty, QueryNodeType.All))); } else { this.PushToken(token); } } if (path != null) { this.ParseRelativePath(path); } return(path); }
XPathExprList ParseAbsolutePath() { XPathExprList path = null; XPathToken token = this.NextToken(); if (null != token) { switch (token.TokenID) { default: this.PushToken(token); break; case XPathTokenID.Slash: path = new XPathExprList(); path.Add(new XPathStepExpr(new NodeSelectCriteria(QueryAxisType.Child, NodeQName.Empty, QueryNodeType.Root))); break; case XPathTokenID.DblSlash: // '//' is special. If found at the start of an absolute path, it implies that the descendant-or-self axis // is applied to the ROOT path = new XPathExprList(); path.Add(new XPathStepExpr(new NodeSelectCriteria(QueryAxisType.Child, NodeQName.Empty, QueryNodeType.Root))); path.Add(new XPathStepExpr(new NodeSelectCriteria(QueryAxisType.DescendantOrSelf, NodeQName.Empty, QueryNodeType.All))); break; } } if (null != path) { this.ParseRelativePath(path); } return(path); }
private XPathExpr ParseFunctionExpression() { XPathExpr expr; XPathToken token = this.NextToken(XPathTokenID.Function); if (token == null) { return(null); } NodeQName name = this.QualifyName(token.Prefix, token.Name); this.NextToken(XPathTokenID.LParen, QueryCompileError.InvalidFunction); XPathExprList args = new XPathExprList(); while ((expr = this.ParseExpression()) != null) { args.Add(expr); if (this.NextToken(XPathTokenID.Comma) == null) { break; } } XPathExpr expr2 = null; if (this.functionLibraries != null) { QueryFunction function = null; for (int i = 0; i < this.functionLibraries.Length; i++) { function = this.functionLibraries[i].Bind(name.Name, name.Namespace, args); if (function != null) { expr2 = new XPathFunctionExpr(function, args); break; } } } if ((expr2 == null) && (this.context != null)) { XPathResultType[] argTypes = new XPathResultType[args.Count]; for (int j = 0; j < args.Count; j++) { argTypes[j] = XPathXsltFunctionExpr.ConvertTypeToXslt(args[j].ReturnType); } string prefix = this.context.LookupPrefix(name.Namespace); IXsltContextFunction function2 = this.context.ResolveFunction(prefix, name.Name, argTypes); if (function2 != null) { expr2 = new XPathXsltFunctionExpr(this.context, function2, args); } } if (expr2 == null) { this.ThrowError(QueryCompileError.UnsupportedFunction); } this.NextToken(XPathTokenID.RParen, QueryCompileError.InvalidFunction); return(expr2); }
private XPathExpr ParseNumberExpression() { XPathToken token = this.NextTokenClass(XPathTokenID.Number); if (token != null) { return(new XPathNumberExpr(token.Number)); } return(null); }
private XPathToken NextToken(XPathTokenID id, QueryCompileError error) { XPathToken token = this.NextToken(id); if (token == null) { this.ThrowError(error); } return(token); }
private XPathExpr ParseLiteralExpression() { XPathToken token = this.NextToken(XPathTokenID.Literal); if (token != null) { return(new XPathStringExpr(token.Name)); } return(null); }
XPathExpr ParseRelationalExpression() { XPathExpr leftExpr = this.ParseAdditiveExpression(); if (null != leftExpr) { RelationOperator op; do { op = RelationOperator.None; XPathToken token = this.NextToken(); if (null != token) { switch (token.TokenID) { default: this.PushToken(token); break; case XPathTokenID.Lt: op = RelationOperator.Lt; break; case XPathTokenID.Lte: op = RelationOperator.Le; break; case XPathTokenID.Gt: op = RelationOperator.Gt; break; case XPathTokenID.Gte: op = RelationOperator.Ge; break; } if (RelationOperator.None != op) { XPathExpr rightExpr = this.ParseAdditiveExpression(); if (null == rightExpr) { this.ThrowError(QueryCompileError.InvalidExpression); } leftExpr = new XPathRelationExpr(op, leftExpr, rightExpr); } } } while (RelationOperator.None != op); } return(leftExpr); }
internal XPathLexer(string xpath, bool resolveKeywords) { this.resolveKeywords = resolveKeywords; this.xpath = string.Copy(xpath); this.xpathLength = this.xpath.Length; this.tokenStart = 0; this.currChar = 0; this.ch = '\0'; this.previousID = XPathTokenID.Unknown; this.token = new XPathToken(); this.ConsumeWhitespace(); }
private XPathToken NextToken(XPathTokenID id) { XPathToken token = this.NextToken(); if (token != null) { if (id == token.TokenID) { return token; } this.readToken = token; } return null; }
private XPathToken NextTokenClass(XPathTokenID tokenClass) { XPathToken token = this.NextToken(); if (token != null) { if ((token.TokenID & tokenClass) != XPathTokenID.Unknown) { return token; } this.readToken = token; } return null; }
XPathExpr ParseMultiplicativeExpression() { XPathExpr leftExpr = this.ParseUnaryExpression(); if (null != leftExpr) { MathOperator op; do { op = MathOperator.None; XPathToken token = this.NextToken(); if (null != token) { switch (token.TokenID) { default: this.PushToken(token); break; case XPathTokenID.Multiply: op = MathOperator.Multiply; break; case XPathTokenID.Div: op = MathOperator.Div; break; case XPathTokenID.Mod: op = MathOperator.Mod; break; } if (MathOperator.None != op) { XPathExpr rightExpr = this.ParseUnaryExpression(); if (null == rightExpr) { this.ThrowError(QueryCompileError.InvalidExpression); } leftExpr = new XPathMathExpr(op, leftExpr, rightExpr); } } } while (MathOperator.None != op); } return(leftExpr); }
private XPathToken NextToken(XPathTokenID id) { XPathToken token = this.NextToken(); if (token != null) { if (id == token.TokenID) { return(token); } this.readToken = token; } return(null); }
private XPathToken NextTokenClass(XPathTokenID tokenClass) { XPathToken token = this.NextToken(); if (token != null) { if ((token.TokenID & tokenClass) != XPathTokenID.Unknown) { return(token); } this.readToken = token; } return(null); }
private XPathExpr ParseRelationalExpression() { XPathExpr left = this.ParseAdditiveExpression(); if (left != null) { RelationOperator none; do { none = RelationOperator.None; XPathToken token = this.NextToken(); if (token != null) { switch (token.TokenID) { case XPathTokenID.Gt: none = RelationOperator.Gt; break; case XPathTokenID.Gte: none = RelationOperator.Ge; break; case XPathTokenID.Lt: none = RelationOperator.Lt; break; case XPathTokenID.Lte: none = RelationOperator.Le; break; default: this.PushToken(token); break; } if (none != RelationOperator.None) { XPathExpr right = this.ParseAdditiveExpression(); if (right == null) { this.ThrowError(QueryCompileError.InvalidExpression); } left = new XPathRelationExpr(none, left, right); } } }while (none != RelationOperator.None); } return(left); }
XPathToken NextTokenClass(XPathTokenID tokenClass) { XPathToken token = this.NextToken(); if (null != token) { if (0 != (token.TokenID & tokenClass)) { return(token); } this.readToken = token; } return(null); }
XPathToken NextToken(XPathTokenID id) { XPathToken token = this.NextToken(); if (null != token) { if (id == token.TokenID) { return token; } this.readToken = token; } return null; }
private XPathToken NextToken() { if (this.readToken == null) { while (this.lexer.MoveNext()) { if (XPathTokenID.Whitespace != this.lexer.Token.TokenID) { return this.lexer.Token; } } return null; } XPathToken readToken = this.readToken; this.readToken = null; return readToken; }
private XPathToken NextToken() { if (this.readToken == null) { while (this.lexer.MoveNext()) { if (XPathTokenID.Whitespace != this.lexer.Token.TokenID) { return(this.lexer.Token); } } return(null); } XPathToken readToken = this.readToken; this.readToken = null; return(readToken); }
private XPathExpr ParseMultiplicativeExpression() { XPathExpr left = this.ParseUnaryExpression(); if (left != null) { MathOperator none; do { none = MathOperator.None; XPathToken token = this.NextToken(); if (token != null) { XPathTokenID tokenID = token.TokenID; if (tokenID == XPathTokenID.Multiply) { none = MathOperator.Multiply; } else if (tokenID == XPathTokenID.Mod) { none = MathOperator.Mod; } else if (tokenID == XPathTokenID.Div) { none = MathOperator.Div; } else { this.PushToken(token); } if (none != MathOperator.None) { XPathExpr right = this.ParseUnaryExpression(); if (right == null) { this.ThrowError(QueryCompileError.InvalidExpression); } left = new XPathMathExpr(none, left, right); } } }while (none != MathOperator.None); } return(left); }
internal XPathExpr Parse() { XPathExpr expr = this.ParseExpression(); if (null == expr) { this.ThrowError(QueryCompileError.InvalidExpression); } // If we stopped before the entire xpath was lexed, we hit something we could not tokenize XPathToken lastToken = this.NextToken(); if (null != lastToken) { this.ThrowError(QueryCompileError.UnexpectedToken); } return(expr); }
XPathToken NextToken() { if (null != this.readToken) { XPathToken nextToken = this.readToken; this.readToken = null; return nextToken; } while (this.lexer.MoveNext()) { if (XPathTokenID.Whitespace != this.lexer.Token.TokenID) { return this.lexer.Token; } } return null; }
internal XPathExpr ParseVariableExpression() { XPathExpr expr = null; if (this.context != null) { XPathToken token = this.NextToken(XPathTokenID.Variable); if (token != null) { NodeQName name = this.QualifyName(token.Prefix, token.Name); string prefix = this.context.LookupPrefix(name.Namespace); IXsltContextVariable variable = this.context.ResolveVariable(prefix, name.Name); if (variable != null) { expr = new XPathXsltVariableExpr(this.context, variable); } } } return(expr); }
XPathToken NextToken() { if (null != this.readToken) { XPathToken nextToken = this.readToken; this.readToken = null; return(nextToken); } while (this.lexer.MoveNext()) { if (XPathTokenID.Whitespace != this.lexer.Token.TokenID) { return(this.lexer.Token); } } return(null); }
private XPathExpr ParseAdditiveExpression() { XPathExpr left = this.ParseMultiplicativeExpression(); if (left != null) { MathOperator none; do { none = MathOperator.None; XPathToken token = this.NextToken(); if (token != null) { switch (token.TokenID) { case XPathTokenID.Plus: none = MathOperator.Plus; break; case XPathTokenID.Minus: none = MathOperator.Minus; break; default: this.PushToken(token); break; } if (none != MathOperator.None) { XPathExpr right = this.ParseMultiplicativeExpression(); if (right == null) { this.ThrowError(QueryCompileError.InvalidExpression); } left = new XPathMathExpr(none, left, right); } } }while (none != MathOperator.None); } return(left); }
private QueryAxisType ParseAxisSpecifier() { if (this.NextToken(XPathTokenID.AtSign) != null) { return(QueryAxisType.Attribute); } QueryAxisType none = QueryAxisType.None; XPathToken token = this.NextTokenClass(XPathTokenID.Axis); if (token != null) { switch (token.TokenID) { case XPathTokenID.Attribute: none = QueryAxisType.Attribute; break; case XPathTokenID.Child: none = QueryAxisType.Child; break; case XPathTokenID.Descendant: none = QueryAxisType.Descendant; break; case XPathTokenID.DescendantOrSelf: none = QueryAxisType.DescendantOrSelf; break; case XPathTokenID.Self: none = QueryAxisType.Self; break; default: this.ThrowError(QueryCompileError.UnsupportedAxis); break; } this.NextToken(XPathTokenID.DblColon, QueryCompileError.InvalidAxisSpecifier); } return(none); }
internal XPathLexer(string xpath, bool resolveKeywords) { this.resolveKeywords = resolveKeywords; // Hold on to a copy of the string so it can't be changed out from under us this.xpath = string.Copy(xpath); this.xpathLength = this.xpath.Length; // Start at the beginning this.tokenStart = 0; this.currChar = 0; this.ch = char.MinValue; this.previousID = XPathTokenID.Unknown; // We will not create new tokens, we will simply change the old one. // This will be the only XPathToken instance created by the lexer // The 'next token' data can be more quickly communicated to the parser if they both hold a reference to the data. this.token = new XPathToken(); // Strip leading whitespace ConsumeWhitespace(); }
private void PushToken(XPathToken token) { this.readToken = token; }
XPathExpr ParseFunctionExpression() { XPathToken functionToken = this.NextToken(XPathTokenID.Function); if (null == functionToken) { return(null); } NodeQName functionName = this.QualifyName(functionToken.Prefix, functionToken.Name); this.NextToken(XPathTokenID.LParen, QueryCompileError.InvalidFunction); XPathExprList args = new XPathExprList(); // Read in arguments XPathExpr arg; while (null != (arg = this.ParseExpression())) { args.Add(arg); if (null == this.NextToken(XPathTokenID.Comma)) { break; } } // Bind to the function // Try each library until we can bind the function XPathExpr functionImpl = null; if (null != this.functionLibraries) { QueryFunction fun = null; for (int i = 0; i < this.functionLibraries.Length; ++i) { if (null != (fun = this.functionLibraries[i].Bind(functionName.Name, functionName.Namespace, args))) { functionImpl = new XPathFunctionExpr(fun, args); break; } } } // Try to bind using the XsltContext if (null == functionImpl && this.context != null) { XPathResultType[] argTypes = new XPathResultType[args.Count]; for (int i = 0; i < args.Count; ++i) { argTypes[i] = XPathXsltFunctionExpr.ConvertTypeToXslt(args[i].ReturnType); } string prefix = this.context.LookupPrefix(functionName.Namespace); IXsltContextFunction xsltFun = this.context.ResolveFunction(prefix, functionName.Name, argTypes); if (xsltFun != null) { functionImpl = new XPathXsltFunctionExpr(this.context, xsltFun, args); } } if (null == functionImpl) { this.ThrowError(QueryCompileError.UnsupportedFunction); } this.NextToken(XPathTokenID.RParen, QueryCompileError.InvalidFunction); return(functionImpl); }
private NodeSelectCriteria ParseNodeTest(QueryAxisType axisType) { QueryNodeType principalNodeType; QueryAxis axis = QueryDataModel.GetAxis(axisType); NodeQName empty = NodeQName.Empty; XPathToken token = this.NextTokenClass(XPathTokenID.NameTest); if (token != null) { switch (token.TokenID) { case XPathTokenID.Wildcard: empty = new NodeQName(QueryDataModel.Wildcard, QueryDataModel.Wildcard); goto Label_0085; case XPathTokenID.NameWildcard: empty = this.QualifyName(token.Prefix, QueryDataModel.Wildcard); goto Label_0085; case XPathTokenID.NameTest: empty = this.QualifyName(token.Prefix, token.Name); goto Label_0085; } this.ThrowError(QueryCompileError.UnexpectedToken); } Label_0085: principalNodeType = QueryNodeType.Any; if (!empty.IsEmpty) { principalNodeType = axis.PrincipalNodeType; } else { token = this.NextTokenClass(XPathTokenID.NodeType); if (token == null) { return(null); } switch (token.TokenID) { case XPathTokenID.Comment: principalNodeType = QueryNodeType.Comment; break; case XPathTokenID.Text: principalNodeType = QueryNodeType.Text; break; case XPathTokenID.Processing: principalNodeType = QueryNodeType.Processing; break; case XPathTokenID.Node: principalNodeType = QueryNodeType.All; break; default: this.ThrowError(QueryCompileError.UnsupportedNodeTest); break; } if (((byte)(axis.ValidNodeTypes & principalNodeType)) == 0) { this.ThrowError(QueryCompileError.InvalidNodeType); } this.NextToken(XPathTokenID.LParen, QueryCompileError.InvalidNodeTest); this.NextToken(XPathTokenID.RParen, QueryCompileError.InvalidNodeTest); } return(new NodeSelectCriteria(axisType, empty, principalNodeType)); }
void PushToken(XPathToken token) { Fx.Assert(null == this.readToken, ""); this.readToken = token; }
XPathToken NextTokenClass(XPathTokenID tokenClass) { XPathToken token = this.NextToken(); if (null != token) { if (0 != (token.TokenID & tokenClass)) { return token; } this.readToken = token; } return null; }