internal XPathXsltVariableExpr(XsltContext context, IXsltContextVariable variable)
: base(XPathExprType.XsltVariable, XPathXsltFunctionExpr.ConvertTypeFromXslt(variable.VariableType))
{
Fx.Assert(null != variable, "");
this.variable = variable;
this.context = context;
}
internal override void SetXsltContext(XsltContext context)
{
if (context == null)
{
throw new XPathException(Res.Xp_UndefinedXsltContext, Prefix, Name);
}
if (xsltContextVariable == null)
{
xsltContextVariable = context.ResolveVariable(Prefix, Name);
Debug.Assert(xsltContextVariable != null, "XSLT has to resolve it or throw exception");
}
else
{
Debug.Assert(xsltContextVariable == context.ResolveVariable(Prefix, Name), "ResolveVariable supposed to return the same VariableAction each time");
}
Object result = xsltContextVariable.Evaluate(context);
if (result is double)
{
_VarQuery = new OperandQuery(result, XPathResultType.Number);
}
else if (result is String)
{
_VarQuery = new OperandQuery(result, XPathResultType.String);
}
else if (result is Boolean)
{
_VarQuery = new OperandQuery(result, XPathResultType.Boolean);
}
else if (result is XPathNavigator)
{
_VarQuery = new NavigatorQuery((XPathNavigator)result);
}
else if (result is ResetableIterator)
{
ResetableIterator it = result as ResetableIterator;
_VarQuery = new XmlIteratorQuery((ResetableIterator)it.Clone());
}
else if (result is XPathNodeIterator)
{
Debug.Assert(false, "Unexpected type of XPathNodeIterator");
throw new NotSupportedException(Res.GetString(Res.XmlUnsupportedType, result.GetType().FullName));
}
else if (result is int)
{
_VarQuery = new OperandQuery(XmlConvert.ToXPathDouble(result), XPathResultType.Number);
}
else
{
if (result == null)
{
throw new XPathException(Res.Xslt_InvalidVariable, Name);
}
Debug.Assert(false, "Unexpected variable type");
throw new NotSupportedException(Res.GetString(Res.XmlUnsupportedType, result.GetType().FullName));
}
Debug.Assert(_VarQuery != null);
}
public override IXsltContextVariable ResolveVariable(string prefix, string name)
{
IXsltContextVariable ret = this.Variables.Peek().Resolve(name);
if (ret == null)
{
throw new XsltException("Invalid variable: " + name);
}
return(ret);
}
// --------------------------- XsltContext -------------------
// Resolving variables and functions
public override IXsltContextVariable ResolveVariable(string prefix, string name)
{
string namespaceURI = this.LookupNamespace(prefix);
XmlQualifiedName qname = new XmlQualifiedName(name, namespaceURI);
IXsltContextVariable variable = this.manager.VariableScope.ResolveVariable(qname);
if (variable == null)
{
throw XsltException.Create(Res.Xslt_InvalidVariable, qname.ToString());
}
return(variable);
}
public override void SetXsltContext(XsltContext context) {
if (context == null) {
throw XPathException.Create(Res.Xp_NoContext);
}
if (this.xsltContext != context) {
xsltContext = context;
variable = xsltContext.ResolveVariable(prefix, name);
// Since null is allowed for ResolveFunction, allow it for ResolveVariable as well
if (variable == null) {
throw XPathException.Create(Res.Xp_UndefVar, QName);
}
}
}
internal PushXsltVariableOpcode(XsltContext context, IXsltContextVariable variable) : base(OpcodeID.PushXsltVariable)
{
this.xsltContext = context;
this.variable = variable;
this.type = XPathXsltFunctionExpr.ConvertTypeFromXslt(variable.VariableType);
switch (this.type)
{
case ValueDataType.Boolean:
case ValueDataType.Double:
case ValueDataType.Sequence:
case ValueDataType.String:
return;
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new QueryCompileException(QueryCompileError.InvalidType, System.ServiceModel.SR.GetString("QueryVariableTypeNotSupported", new object[] { this.variable.VariableType.ToString() })));
}
public override void SetXsltContext(XsltContext context)
{
if (context == null)
{
throw XPathException.Create("Xp_NoContext");
}
if (base.xsltContext != context)
{
base.xsltContext = context;
this.variable = base.xsltContext.ResolveVariable(base.prefix, base.name);
if (this.variable == null)
{
throw XPathException.Create("Xp_UndefVar", base.QName);
}
}
}
public IXsltContextVariable Resolve(string name)
{
IXsltContextVariable ret = null;
XPathVariable var = this.Find(x => StringComparer.InvariantCulture.Equals(x.Name, name));
if (var != null)
{
ret = var.Evaluate(this.Scope, this.Resolver);
}
else if (this.Parent != null)
{
ret = this.Parent.Resolve(name);
}
return(ret);
}
public override void SetXsltContext(XsltContext context)
{
if (context == null)
{
throw XPathException.Create("Xp_NoContext");
}
if (base.xsltContext != context)
{
base.xsltContext = context;
this.variable = base.xsltContext.ResolveVariable(base.prefix, base.name);
if (this.variable == null)
{
throw XPathException.Create("Xp_UndefVar", base.QName);
}
}
}
public override void SetXsltContext(XsltContext context)
{
if (context == null)
{
throw XPathException.Create(SR.Xp_NoContext);
}
if (this.xsltContext != context)
{
xsltContext = context;
_variable = xsltContext.ResolveVariable(prefix, name);
// Since null is allowed for ResolveFunction, allow it for ResolveVariable as well
if (_variable == null)
{
throw XPathException.Create(SR.Xp_UndefVar, QName);
}
}
}
internal override void SetXsltContext(XsltContext context) {
if (context == null) {
throw new XPathException(Res.Xp_UndefinedXsltContext, Prefix, Name); }
if(xsltContextVariable == null) {
xsltContextVariable = context.ResolveVariable(Prefix, Name);
Debug.Assert(xsltContextVariable != null, "XSLT has to resolve it or throw exception");
}
else {
Debug.Assert(xsltContextVariable == context.ResolveVariable(Prefix, Name), "ResolveVariable supposed to return the same VariableAction each time");
}
Object result = xsltContextVariable.Evaluate(context);
if (result is double) {
_VarQuery = new OperandQuery(result, XPathResultType.Number);
}
else if (result is String) {
_VarQuery = new OperandQuery(result, XPathResultType.String);
}
else if (result is Boolean) {
_VarQuery = new OperandQuery(result, XPathResultType.Boolean);
}
else if (result is XPathNavigator) {
_VarQuery = new NavigatorQuery((XPathNavigator)result);
}
else if (result is ResetableIterator) {
ResetableIterator it = result as ResetableIterator;
_VarQuery = new XmlIteratorQuery( (ResetableIterator) it.Clone() );
}
else if (result is XPathNodeIterator) {
Debug.Assert(false, "Unexpected type of XPathNodeIterator");
throw new NotSupportedException(Res.GetString(Res.XmlUnsupportedType, result.GetType().FullName));
}
else if (result is int) {
_VarQuery = new OperandQuery(XmlConvert.ToXPathDouble(result), XPathResultType.Number);
}
else {
if (result == null) {
throw new XPathException(Res.Xslt_InvalidVariable, Name);
}
Debug.Assert(false, "Unexpected variable type");
throw new NotSupportedException(Res.GetString(Res.XmlUnsupportedType, result.GetType().FullName));
}
Debug.Assert(_VarQuery != 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);
}
internal PushXsltVariableOpcode(XsltContext context, IXsltContextVariable variable)
: base(OpcodeID.PushXsltVariable)
{
Fx.Assert(null != context && null != variable, "");
this.xsltContext = context;
this.variable = variable;
this.type = XPathXsltFunctionExpr.ConvertTypeFromXslt(variable.VariableType);
// Make sure the type is supported
switch (this.type)
{
case ValueDataType.Boolean:
case ValueDataType.Double:
case ValueDataType.String:
case ValueDataType.Sequence:
break;
default:
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new QueryCompileException(QueryCompileError.InvalidType, SR.GetString(SR.QueryVariableTypeNotSupported, this.variable.VariableType.ToString())));
}
}
public void AddVariable(string prefix, string name, IXsltContextVariable variable)
{
var key = new XmlName(name, prefix ?? string.Empty);
AddVariable(key, variable);
}
private VariableQuery(VariableQuery other) : base(other)
{
_variable = other._variable;
}
private VariableQuery(VariableQuery other)
: base(other)
{
this.variable = other.variable;
}
internal XPathXsltVariableExpr(XsltContext context, IXsltContextVariable variable)
: base(XPathExprType.XsltVariable, XPathXsltFunctionExpr.ConvertTypeFromXslt(variable.VariableType))
{
Fx.Assert(null != variable, "");
this.variable = variable;
this.context = context;
}
private VariableQuery(VariableQuery other) : base(other)
{
this.variable = other.variable;
}
public void AddVariable(XmlName name, IXsltContextVariable variable)
{
EnsureVariables()[name] = variable;
}
private VariableQuery(VariableQuery other) : base(other)
{
_variable = other._variable;
}
public void AddVariable(XmlName name, IXsltContextVariable variable)
{
EnsureVariables()[name] = variable;
}
internal PushXsltVariableOpcode(XsltContext context, IXsltContextVariable variable)
: base(OpcodeID.PushXsltVariable)
{
Fx.Assert(null != context && null != variable, "");
this.xsltContext = context;
this.variable = variable;
this.type = XPathXsltFunctionExpr.ConvertTypeFromXslt(variable.VariableType);
// Make sure the type is supported
switch (this.type)
{
case ValueDataType.Boolean:
case ValueDataType.Double:
case ValueDataType.String:
case ValueDataType.Sequence:
break;
default:
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new QueryCompileException(QueryCompileError.InvalidType, SR.GetString(SR.QueryVariableTypeNotSupported, this.variable.VariableType.ToString())));
}
}
public void AddVariable(string prefix, string name, IXsltContextVariable variable)
{
var key = new XmlName(name, prefix ?? string.Empty);
AddVariable(key, variable);
}
