internal QueryAxis(QueryAxisType type, AxisDirection direction, QueryNodeType principalNode, QueryNodeType validNodeTypes)
{
this.direction = direction;
this.principalNode = principalNode;
this.type = type;
this.validNodeTypes = validNodeTypes;
}
internal QueryAxis(QueryAxisType type, AxisDirection direction, QueryNodeType principalNode, QueryNodeType validNodeTypes)
{
this.direction = direction;
this.principalNode = principalNode;
this.type = type;
this.validNodeTypes = validNodeTypes;
}
internal NodeSelectCriteria(QueryAxisType axis, NodeQName qname, QueryNodeType nodeType)
{
this.axis = QueryDataModel.GetAxis(axis);
this.qname = qname;
this.qnameType = qname.GetQNameType();
this.type = nodeType;
}
internal NodeSelectCriteria(QueryAxisType axis, NodeQName qname, QueryNodeType nodeType)
{
this.axis = QueryDataModel.GetAxis(axis);
this.qname = qname;
this.qnameType = qname.GetQNameType();
this.type = nodeType;
}
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));
}
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);
}
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);
}
private XPathStepExpr ParseStep()
{
QueryAxisType axisType = this.ParseAxisSpecifier();
NodeSelectCriteria desc = null;
bool flag = false;
if (axisType != QueryAxisType.None)
{
desc = this.ParseNodeTest(axisType);
}
else if (this.NextToken(XPathTokenID.Period) != null)
{
desc = new NodeSelectCriteria(QueryAxisType.Self, NodeQName.Empty, QueryNodeType.All);
flag = true;
}
else if (this.NextToken(XPathTokenID.DblPeriod) != null)
{
desc = new NodeSelectCriteria(QueryAxisType.Parent, NodeQName.Empty, QueryNodeType.Ancestor);
flag = true;
}
else
{
desc = this.ParseNodeTest(QueryAxisType.Child);
if (desc == null)
{
return(null);
}
}
if (desc == null)
{
this.ThrowError(QueryCompileError.InvalidLocationStep);
}
XPathExprList predicates = null;
if (!flag)
{
predicates = this.ParsePredicates();
}
return(new XPathStepExpr(desc, predicates));
}
internal static NodeSelectCriteria Create(QueryAxisType axis, NodeQName qname, QueryNodeType nodeType)
{
return new NodeSelectCriteria(axis, qname, nodeType);
}
internal static QueryAxis GetAxis(QueryAxisType type)
{
return QueryDataModel.axes[(int)type];
}
internal static QueryAxis GetAxis(QueryAxisType type)
{
return(axes[(int)type]);
}
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);
}
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));
}
internal static QueryAxis GetAxis(QueryAxisType type)
{
return axes[(int) type];
}
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);
}
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));
}
internal static NodeSelectCriteria Create(QueryAxisType axis, NodeQName qname, QueryNodeType nodeType)
{
return(new NodeSelectCriteria(axis, qname, nodeType));
}
internal static QueryAxis GetAxis(QueryAxisType type)
{
return(QueryDataModel.axes[(int)type]);
}
