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) { }