public DefaultFunctionCall (XQueryStaticContext ctx, string name, int minArgs, int maxArgs, SequenceType type, ExprSequence args)
: base (GetName (name), args)
{
this.type = type;
this.minArgs = minArgs;
this.maxArgs = maxArgs;
}
internal static SequenceType ComputeCommonBase (SequenceType t1, SequenceType t2)
{
// FIXME: implement
// throw new NotImplementedException ();
return SequenceType.AnyType;
}
internal static SequenceType Create (XmlSchemaType schemaType, Occurence occurence)
{
switch (schemaType.QualifiedName.Namespace) {
case XmlSchema.Namespace:
case InternalPool.XdtNamespace:
break;
default:
return new SequenceType (schemaType, occurence);
}
Hashtable cacheForType = standardTypes [schemaType] as Hashtable;
if (cacheForType == null) {
cacheForType = new Hashtable ();
standardTypes [schemaType] = cacheForType;
} else {
SequenceType type = cacheForType [occurence] as SequenceType;
if (type != null)
return type;
}
SequenceType t = new SequenceType (schemaType, occurence);
cacheForType [occurence] = t;
return t;
}
private ConvertingIterator (ConvertingIterator other)
: base (other)
{
iter = other.iter.Clone ();
type = other.type;
}
public ConvertingIterator (XPathSequence iter, SequenceType type)
: base (iter.Context)
{
this.iter = iter;
this.type = type;
}
public TreatExpr (ExprSingle expr, SequenceType type)
: base (expr, type)
{
}
public XQueryVariable (XmlQualifiedName name, SequenceType type, ExprSequence varBody)
{
this.name = name;
this.type = type;
this.varBody = varBody; // might be null (just declaration).
}
public XQueryFunctionArgument (XmlQualifiedName name, SequenceType type)
{
this.name = name;
this.type = type;
}
// FIXME: use IXmlNamespaceResolver.LookupPrefix() in ctx
public AtomicConstructorCall (XQueryStaticContext ctx, SequenceType type, XPathItemExpression [] args)
: base (ctx, type.SchemaType.QualifiedName.Name, 1, 1, type, args)
{
}
private XQueryCliFunction (XmlQualifiedName name,
XQueryFunctionArgument [] args,
SequenceType returnType,
Hashtable methods,
int minArgs,
int maxArgs)
: base (name, args, returnType)
{
this.methods = methods;
this.maxArgs = maxArgs;
this.minArgs = minArgs;
}
protected TypeOperationExpr (ExprSingle expr, SequenceType type)
{
this.expr = expr;
this.type = type;
}
public CaseClause (SequenceType type, ExprSingle expr, XmlQualifiedName varName)
{
this.type = type;
this.expr = expr;
this.varName = varName;
}
public QuantifiedExprBody (XmlQualifiedName varName,
SequenceType type, ExprSingle expr)
{
this.varName = varName;
this.type = type ;
this.expr = expr;
}
public LetSingleBody (XmlQualifiedName varName, SequenceType type, ExprSingle expr)
: base (varName, type, expr)
{
}
public ForSingleBody (XmlQualifiedName varName, SequenceType type, XmlQualifiedName positionalVar, ExprSingle expr)
: base (varName, type, expr)
{
this.positionalVar = positionalVar;
}
internal bool CanConvertTo (SequenceType other)
{
// FIXME: implement precisely
return this == other;
// throw new NotImplementedException ();
}
// Constructor
internal XQueryFunction (XmlQualifiedName name, XQueryFunctionArgument [] args, SequenceType returnType)
{
this.name = name;
this.args = args;
this.returnType = returnType;
}
internal void CheckSchemaType (SequenceType type)
{
if (type == null)
return;
type.ItemType.CheckReference (this);
}
internal XQueryUserFunction (XmlQualifiedName name,
XQueryFunctionArgument [] parameters,
ExprSequence expr,
SequenceType returnType)
: base (name, parameters, returnType)
{
this.expr = expr;
}
internal void CheckType (ExprSingle expr, SequenceType type)
{
if (!expr.StaticType.CanConvertTo (type))
throw new XmlQueryCompileException (String.Format ("Cannot convert type from {0} to {1}", expr.StaticType, type));
}
public FunctionDeclaration (XmlQualifiedName name,
XQueryFunctionArgumentList parameters,
SequenceType type,
EnclosedExpr expr)
{
this.name = name;
this.parameters = parameters;
this.returnType = type;
this.funcBody = expr;
}
public InstanceOfExpr (ExprSingle expr, SequenceType type)
: base (expr, type)
{
}
