mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
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
1039 lines
32 KiB
C#
1039 lines
32 KiB
C#
//------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//------------------------------------------------------------
|
|
namespace System.ServiceModel.Dispatcher
|
|
{
|
|
using System.Runtime;
|
|
using System.Xml;
|
|
using System.Xml.XPath;
|
|
using System.Xml.Xsl;
|
|
|
|
class XPathParser
|
|
{
|
|
IFunctionLibrary[] functionLibraries;
|
|
XPathLexer lexer;
|
|
XmlNamespaceManager namespaces;
|
|
XPathToken readToken;
|
|
XsltContext context;
|
|
|
|
internal XPathParser(string xpath, XmlNamespaceManager namespaces, IFunctionLibrary[] functionLibraries)
|
|
{
|
|
Fx.Assert(null != xpath, "");
|
|
this.functionLibraries = functionLibraries;
|
|
this.namespaces = namespaces;
|
|
this.lexer = new XPathLexer(xpath);
|
|
this.context = namespaces as XsltContext;
|
|
}
|
|
|
|
XPathExpr EnsureReturnsNodeSet(XPathExpr expr)
|
|
{
|
|
if (expr.ReturnType != ValueDataType.Sequence)
|
|
{
|
|
this.ThrowError(QueryCompileError.InvalidFunction);
|
|
}
|
|
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;
|
|
}
|
|
|
|
XPathToken NextToken(XPathTokenID id)
|
|
{
|
|
XPathToken token = this.NextToken();
|
|
|
|
if (null != token)
|
|
{
|
|
if (id == token.TokenID)
|
|
{
|
|
return token;
|
|
}
|
|
|
|
this.readToken = token;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
XPathToken NextToken(XPathTokenID id, QueryCompileError error)
|
|
{
|
|
XPathToken token = this.NextToken(id);
|
|
|
|
if (null == token)
|
|
{
|
|
this.ThrowError(error);
|
|
}
|
|
|
|
return token;
|
|
}
|
|
|
|
XPathToken NextTokenClass(XPathTokenID tokenClass)
|
|
{
|
|
XPathToken token = this.NextToken();
|
|
|
|
if (null != token)
|
|
{
|
|
if (0 != (token.TokenID & tokenClass))
|
|
{
|
|
return token;
|
|
}
|
|
|
|
this.readToken = token;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
NodeQName QualifyName(string prefix, string name)
|
|
{
|
|
if (null != this.namespaces && null != prefix && prefix.Length > 0)
|
|
{
|
|
prefix = this.namespaces.NameTable.Add(prefix);
|
|
|
|
string ns = this.namespaces.LookupNamespace(prefix);
|
|
|
|
if (null == ns)
|
|
{
|
|
this.ThrowError(QueryCompileError.NoNamespaceForPrefix);
|
|
}
|
|
|
|
return new NodeQName(name, ns);
|
|
}
|
|
|
|
return new NodeQName(name);
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
XPathExpr ParseAdditiveExpression()
|
|
{
|
|
XPathExpr leftExpr = this.ParseMultiplicativeExpression();
|
|
|
|
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.Plus:
|
|
op = MathOperator.Plus;
|
|
break;
|
|
|
|
case XPathTokenID.Minus:
|
|
op = MathOperator.Minus;
|
|
break;
|
|
}
|
|
if (MathOperator.None != op)
|
|
{
|
|
XPathExpr rightExpr = this.ParseMultiplicativeExpression();
|
|
|
|
if (null == rightExpr)
|
|
{
|
|
this.ThrowError(QueryCompileError.InvalidExpression);
|
|
}
|
|
|
|
leftExpr = new XPathMathExpr(op, leftExpr, rightExpr);
|
|
}
|
|
}
|
|
} while (MathOperator.None != op);
|
|
}
|
|
|
|
return leftExpr;
|
|
}
|
|
|
|
XPathExpr ParseAndExpression()
|
|
{
|
|
XPathExpr eqExpr = this.ParseEqualityExpression();
|
|
|
|
if (null != eqExpr && null != this.NextToken(XPathTokenID.And))
|
|
{
|
|
XPathExpr andExpr = new XPathExpr(XPathExprType.And, ValueDataType.Boolean);
|
|
|
|
andExpr.AddBooleanExpression(XPathExprType.And, eqExpr);
|
|
do
|
|
{
|
|
eqExpr = this.ParseEqualityExpression();
|
|
if (eqExpr == null)
|
|
this.ThrowError(QueryCompileError.InvalidExpression);
|
|
andExpr.AddBooleanExpression(XPathExprType.And, eqExpr);
|
|
} while (null != this.NextToken(XPathTokenID.And));
|
|
|
|
return andExpr;
|
|
}
|
|
|
|
return eqExpr;
|
|
}
|
|
|
|
QueryAxisType ParseAxisSpecifier()
|
|
{
|
|
if (null != this.NextToken(XPathTokenID.AtSign))
|
|
{
|
|
return QueryAxisType.Attribute;
|
|
}
|
|
|
|
QueryAxisType axisType = QueryAxisType.None;
|
|
XPathToken token;
|
|
|
|
if (null != (token = this.NextTokenClass(XPathTokenID.Axis)))
|
|
{
|
|
switch (token.TokenID)
|
|
{
|
|
default:
|
|
this.ThrowError(QueryCompileError.UnsupportedAxis);
|
|
break;
|
|
|
|
case XPathTokenID.Attribute:
|
|
axisType = QueryAxisType.Attribute;
|
|
break;
|
|
|
|
case XPathTokenID.Child:
|
|
axisType = QueryAxisType.Child;
|
|
break;
|
|
|
|
case XPathTokenID.Descendant:
|
|
axisType = QueryAxisType.Descendant;
|
|
break;
|
|
|
|
case XPathTokenID.DescendantOrSelf:
|
|
axisType = QueryAxisType.DescendantOrSelf;
|
|
break;
|
|
|
|
case XPathTokenID.Self:
|
|
axisType = QueryAxisType.Self;
|
|
break;
|
|
}
|
|
|
|
// axis specifiers must be followed by a '::'
|
|
this.NextToken(XPathTokenID.DblColon, QueryCompileError.InvalidAxisSpecifier);
|
|
}
|
|
|
|
return axisType;
|
|
}
|
|
|
|
XPathExpr ParseEqualityExpression()
|
|
{
|
|
XPathExpr leftExpr = this.ParseRelationalExpression();
|
|
|
|
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.Eq:
|
|
op = RelationOperator.Eq;
|
|
break;
|
|
|
|
case XPathTokenID.Neq:
|
|
op = RelationOperator.Ne;
|
|
break;
|
|
}
|
|
if (RelationOperator.None != op)
|
|
{
|
|
XPathExpr rightExpr = this.ParseRelationalExpression();
|
|
|
|
if (null == rightExpr)
|
|
{
|
|
this.ThrowError(QueryCompileError.InvalidExpression);
|
|
}
|
|
|
|
leftExpr = new XPathRelationExpr(op, leftExpr, rightExpr);
|
|
}
|
|
}
|
|
} while (RelationOperator.None != op);
|
|
}
|
|
|
|
return leftExpr;
|
|
}
|
|
|
|
XPathExpr ParseExpression()
|
|
{
|
|
return this.ParseOrExpression();
|
|
}
|
|
|
|
XPathExpr ParseFilterExpression()
|
|
{
|
|
XPathExpr primaryExpr = this.ParsePrimaryExpression();
|
|
|
|
if (null == primaryExpr)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
XPathExpr filterExpr = new XPathExpr(XPathExprType.Filter, primaryExpr.ReturnType);
|
|
filterExpr.Add(primaryExpr);
|
|
|
|
XPathExpr predicate = this.ParsePredicateExpression();
|
|
|
|
if (null != predicate)
|
|
{
|
|
EnsureReturnsNodeSet(primaryExpr);
|
|
|
|
//XPathExpr filterExpr = new XPathExpr(XPathExprType.Filter, ValueDataType.Sequence);
|
|
|
|
//filterExpr.Add(primaryExpr);
|
|
filterExpr.Add(predicate);
|
|
|
|
// Read in any additional predicates
|
|
while (null != (predicate = this.ParsePredicateExpression()))
|
|
{
|
|
filterExpr.Add(predicate);
|
|
}
|
|
|
|
return filterExpr;
|
|
}
|
|
|
|
return primaryExpr;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
internal XPathExpr ParseLocationPath()
|
|
{
|
|
XPathExprList path = this.ParseAbsolutePath();
|
|
|
|
if (null == path)
|
|
{
|
|
path = this.ParseRelativePath();
|
|
}
|
|
|
|
if (null != path)
|
|
{
|
|
return new XPathExpr(XPathExprType.LocationPath, ValueDataType.Sequence, path);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
XPathExpr ParseLiteralExpression()
|
|
{
|
|
XPathToken literal;
|
|
|
|
if (null != (literal = this.NextToken(XPathTokenID.Literal)))
|
|
{
|
|
return new XPathStringExpr(literal.Name);
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
NodeSelectCriteria ParseNodeTest(QueryAxisType axisType)
|
|
{
|
|
Fx.Assert(QueryAxisType.None != axisType, "");
|
|
|
|
QueryAxis axis = QueryDataModel.GetAxis(axisType);
|
|
XPathToken token;
|
|
NodeQName qname = NodeQName.Empty;
|
|
|
|
if (null != (token = this.NextTokenClass(XPathTokenID.NameTest)))
|
|
{
|
|
switch (token.TokenID)
|
|
{
|
|
default:
|
|
this.ThrowError(QueryCompileError.UnexpectedToken);
|
|
break;
|
|
|
|
case XPathTokenID.Wildcard:
|
|
qname = new NodeQName(QueryDataModel.Wildcard, QueryDataModel.Wildcard);
|
|
break;
|
|
|
|
case XPathTokenID.NameTest:
|
|
qname = this.QualifyName(token.Prefix, token.Name);
|
|
break;
|
|
|
|
case XPathTokenID.NameWildcard:
|
|
qname = this.QualifyName(token.Prefix, QueryDataModel.Wildcard);
|
|
break;
|
|
}
|
|
}
|
|
|
|
QueryNodeType nodeType = QueryNodeType.Any;
|
|
|
|
if (qname.IsEmpty)
|
|
{
|
|
// Check for nodeTests
|
|
if (null == (token = this.NextTokenClass(XPathTokenID.NodeType)))
|
|
{
|
|
// Not a NodeTest either.
|
|
return null;
|
|
}
|
|
|
|
switch (token.TokenID)
|
|
{
|
|
default:
|
|
this.ThrowError(QueryCompileError.UnsupportedNodeTest);
|
|
break;
|
|
|
|
case XPathTokenID.Comment:
|
|
nodeType = QueryNodeType.Comment;
|
|
break;
|
|
|
|
case XPathTokenID.Text:
|
|
nodeType = QueryNodeType.Text;
|
|
break;
|
|
|
|
case XPathTokenID.Processing:
|
|
nodeType = QueryNodeType.Processing;
|
|
break;
|
|
|
|
case XPathTokenID.Node:
|
|
nodeType = QueryNodeType.All;
|
|
break;
|
|
}
|
|
|
|
// Make sure the nodes being selected CAN actually be selected from this axis
|
|
if (0 == (axis.ValidNodeTypes & nodeType))
|
|
{
|
|
this.ThrowError(QueryCompileError.InvalidNodeType);
|
|
}
|
|
|
|
// Eat ()
|
|
this.NextToken(XPathTokenID.LParen, QueryCompileError.InvalidNodeTest);
|
|
this.NextToken(XPathTokenID.RParen, QueryCompileError.InvalidNodeTest);
|
|
}
|
|
else
|
|
{
|
|
nodeType = axis.PrincipalNodeType;
|
|
}
|
|
|
|
return new NodeSelectCriteria(axisType, qname, nodeType);
|
|
}
|
|
|
|
XPathExpr ParseNumberExpression()
|
|
{
|
|
XPathToken number;
|
|
|
|
if (null != (number = this.NextTokenClass(XPathTokenID.Number)))
|
|
{
|
|
return new XPathNumberExpr(number.Number);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
XPathExpr ParseOrExpression()
|
|
{
|
|
XPathExpr andExpr = this.ParseAndExpression();
|
|
|
|
if (null != andExpr && null != this.NextToken(XPathTokenID.Or))
|
|
{
|
|
XPathExpr orExpr = new XPathExpr(XPathExprType.Or, ValueDataType.Boolean);
|
|
|
|
orExpr.AddBooleanExpression(XPathExprType.Or, andExpr);
|
|
do
|
|
{
|
|
andExpr = this.ParseAndExpression();
|
|
if (andExpr == null)
|
|
this.ThrowError(QueryCompileError.InvalidExpression);
|
|
orExpr.AddBooleanExpression(XPathExprType.Or, andExpr);
|
|
} while (null != this.NextToken(XPathTokenID.Or));
|
|
|
|
return orExpr;
|
|
}
|
|
|
|
return andExpr;
|
|
}
|
|
|
|
XPathExpr ParsePathExpression()
|
|
{
|
|
XPathExpr pathExpr = this.ParseLocationPath();
|
|
|
|
if (null != pathExpr)
|
|
{
|
|
return pathExpr;
|
|
}
|
|
|
|
// Perhaps we have a filter expression
|
|
XPathExpr filterExpr = this.ParseFilterExpression();
|
|
if (null != filterExpr)
|
|
{
|
|
if (null != this.NextToken(XPathTokenID.Slash))
|
|
{
|
|
EnsureReturnsNodeSet(filterExpr);
|
|
|
|
// Is this a complex filter expression.. i.e. followed by further selections..
|
|
XPathExprList relPath = this.ParseRelativePath();
|
|
if (null == relPath)
|
|
{
|
|
this.ThrowError(QueryCompileError.InvalidLocationPath);
|
|
}
|
|
|
|
XPathExpr relPathExpr = new XPathExpr(XPathExprType.RelativePath, ValueDataType.Sequence, relPath);
|
|
|
|
pathExpr = new XPathExpr(XPathExprType.Path, ValueDataType.Sequence);
|
|
pathExpr.Add(filterExpr);
|
|
pathExpr.Add(relPathExpr);
|
|
}
|
|
else if (null != this.NextToken(XPathTokenID.DblSlash))
|
|
{
|
|
EnsureReturnsNodeSet(filterExpr);
|
|
|
|
XPathExprList relPath = this.ParseRelativePath();
|
|
if (null == relPath)
|
|
{
|
|
this.ThrowError(QueryCompileError.InvalidLocationPath);
|
|
}
|
|
|
|
XPathExpr relPathExpr = new XPathExpr(XPathExprType.RelativePath, ValueDataType.Sequence, relPath);
|
|
pathExpr = new XPathExpr(XPathExprType.Path, ValueDataType.Sequence);
|
|
pathExpr.Add(filterExpr);
|
|
pathExpr.Add(new XPathStepExpr(new NodeSelectCriteria(QueryAxisType.DescendantOrSelf, NodeQName.Empty, QueryNodeType.All)));
|
|
pathExpr.Add(relPathExpr);
|
|
}
|
|
else
|
|
{
|
|
pathExpr = filterExpr;
|
|
}
|
|
}
|
|
|
|
return pathExpr;
|
|
}
|
|
|
|
XPathExprList ParsePredicates()
|
|
{
|
|
XPathExprList predicates = null;
|
|
XPathExpr predicate = this.ParsePredicateExpression();
|
|
|
|
if (null != predicate)
|
|
{
|
|
predicates = new XPathExprList();
|
|
predicates.Add(predicate);
|
|
while (null != (predicate = this.ParsePredicateExpression()))
|
|
{
|
|
predicates.Add(predicate);
|
|
}
|
|
}
|
|
|
|
return predicates;
|
|
}
|
|
|
|
XPathExpr ParsePredicateExpression()
|
|
{
|
|
XPathExpr predicate = null;
|
|
|
|
if (null != this.NextToken(XPathTokenID.LBracket))
|
|
{
|
|
predicate = this.ParseExpression();
|
|
if (null == predicate)
|
|
{
|
|
this.ThrowError(QueryCompileError.InvalidPredicate);
|
|
}
|
|
|
|
this.NextToken(XPathTokenID.RBracket, QueryCompileError.InvalidPredicate);
|
|
}
|
|
|
|
return predicate;
|
|
}
|
|
|
|
XPathExpr ParsePrimaryExpression()
|
|
{
|
|
XPathExpr expr = this.ParseVariableExpression();
|
|
|
|
if (null == expr)
|
|
{
|
|
if (null != this.NextToken(XPathTokenID.LParen))
|
|
{
|
|
expr = this.ParseExpression();
|
|
if (null == expr || null == this.NextToken(XPathTokenID.RParen))
|
|
{
|
|
this.ThrowError(QueryCompileError.InvalidExpression);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (null == expr)
|
|
{
|
|
expr = this.ParseLiteralExpression();
|
|
}
|
|
|
|
if (null == expr)
|
|
{
|
|
expr = this.ParseNumberExpression();
|
|
}
|
|
|
|
if (null == expr)
|
|
{
|
|
expr = this.ParseFunctionExpression();
|
|
}
|
|
|
|
return expr;
|
|
}
|
|
|
|
XPathExprList ParseRelativePath()
|
|
{
|
|
XPathExprList path = new XPathExprList();
|
|
|
|
if (this.ParseRelativePath(path))
|
|
{
|
|
return path;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
XPathStepExpr ParseStep()
|
|
{
|
|
QueryAxisType axis = this.ParseAxisSpecifier();
|
|
NodeSelectCriteria selectDesc = null;
|
|
bool abbreviatedStep = false;
|
|
|
|
if (QueryAxisType.None != axis)
|
|
{
|
|
// Valid axis specifier - must be followed by a nodeTest
|
|
selectDesc = this.ParseNodeTest(axis);
|
|
}
|
|
else
|
|
{
|
|
// No axis specifier. This could be an abbreviated step - shortcuts for 'self' or 'parent'
|
|
if (null != this.NextToken(XPathTokenID.Period))
|
|
{
|
|
selectDesc = new NodeSelectCriteria(QueryAxisType.Self, NodeQName.Empty, QueryNodeType.All);
|
|
abbreviatedStep = true;
|
|
}
|
|
else if (null != this.NextToken(XPathTokenID.DblPeriod))
|
|
{
|
|
// A shortcut for parent
|
|
selectDesc = new NodeSelectCriteria(QueryAxisType.Parent, NodeQName.Empty, QueryNodeType.Ancestor);
|
|
abbreviatedStep = true;
|
|
}
|
|
else
|
|
{
|
|
// No axis specifier provided. Assume child
|
|
if (null == (selectDesc = this.ParseNodeTest(QueryAxisType.Child)))
|
|
{
|
|
// No nodeTest either.. clearly not a Step
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (null == selectDesc)
|
|
{
|
|
this.ThrowError(QueryCompileError.InvalidLocationStep);
|
|
}
|
|
|
|
XPathExprList predicates = null;
|
|
|
|
if (!abbreviatedStep)
|
|
{
|
|
// Abbreviated steps are not permitted predicates
|
|
predicates = this.ParsePredicates();
|
|
}
|
|
|
|
return new XPathStepExpr(selectDesc, predicates);
|
|
}
|
|
|
|
XPathExpr ParseUnaryExpression()
|
|
{
|
|
bool negate = false, anyNegate = false;
|
|
for (; null != this.NextToken(XPathTokenID.Minus); anyNegate = true, negate = !negate);
|
|
XPathExpr expr = ParseUnionExpression();
|
|
if (expr != null)
|
|
{
|
|
// If there were any negations at all, the type gets converted to a number
|
|
if (anyNegate && expr.ReturnType != ValueDataType.Double)
|
|
{
|
|
expr.ReturnType = ValueDataType.Double;
|
|
expr.TypecastRequired = true;
|
|
}
|
|
expr.Negate = negate;
|
|
}
|
|
return expr;
|
|
}
|
|
|
|
internal XPathExpr ParseUnionExpression()
|
|
{
|
|
XPathExpr leftExpr = this.ParsePathExpression();
|
|
|
|
if (null != leftExpr)
|
|
{
|
|
if (null != this.NextToken(XPathTokenID.Pipe))
|
|
{
|
|
EnsureReturnsNodeSet(leftExpr);
|
|
|
|
XPathExpr rightExpr = this.ParseUnionExpression();
|
|
if (rightExpr == null)
|
|
{
|
|
ThrowError(QueryCompileError.CouldNotParseExpression);
|
|
}
|
|
EnsureReturnsNodeSet(rightExpr);
|
|
|
|
return new XPathConjunctExpr(XPathExprType.Union, ValueDataType.Sequence, leftExpr, rightExpr);
|
|
}
|
|
}
|
|
|
|
return leftExpr;
|
|
}
|
|
|
|
internal XPathExpr ParseVariableExpression()
|
|
{
|
|
XPathExpr expr = null;
|
|
if (this.context != null)
|
|
{
|
|
XPathToken varTok = this.NextToken(XPathTokenID.Variable);
|
|
if (varTok != null)
|
|
{
|
|
NodeQName varName = this.QualifyName(varTok.Prefix, varTok.Name);
|
|
string prefix = this.context.LookupPrefix(varName.Namespace);
|
|
|
|
IXsltContextVariable var = this.context.ResolveVariable(prefix, varName.Name);
|
|
if (var != null)
|
|
{
|
|
expr = new XPathXsltVariableExpr(this.context, var);
|
|
}
|
|
}
|
|
}
|
|
return expr;
|
|
}
|
|
|
|
void PushToken(XPathToken token)
|
|
{
|
|
Fx.Assert(null == this.readToken, "");
|
|
this.readToken = token;
|
|
}
|
|
|
|
internal void ThrowError(QueryCompileError error)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new QueryCompileException(error, this.lexer.ConsumedSubstring()));
|
|
}
|
|
|
|
internal struct QName
|
|
{
|
|
string prefix;
|
|
|
|
string name;
|
|
|
|
internal QName(string prefix, string name)
|
|
{
|
|
Fx.Assert(null != prefix, "");
|
|
this.prefix = prefix;
|
|
this.name = name;
|
|
}
|
|
|
|
internal string Prefix
|
|
{
|
|
get
|
|
{
|
|
return this.prefix;
|
|
}
|
|
}
|
|
|
|
internal string Name
|
|
{
|
|
get
|
|
{
|
|
return this.name;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|