public ComparisonExpr (ExprSingle left, ExprSingle right, ComparisonOperator oper) : base (left, right) { this.oper = oper; }
internal override ExprSingle CompileCore (XQueryASTCompiler compiler) { Left = Left.Compile (compiler); Right = Right.Compile (compiler); return this; }
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; }
internal override ExprSingle CompileCore (XQueryASTCompiler compiler) { condition = condition.Compile (compiler); // FIXME: check if condition is constant, and returns trueExpr or falseExpr TrueExpr = TrueExpr.Compile (compiler); FalseExpr = FalseExpr.Compile (compiler); return this; }
public void Insert (int pos, ExprSingle expr) { List.Insert (pos, expr); }
public TypeswitchExpr (ExprSequence switchExpr, CaseClauseList caseList, XmlQualifiedName defaultVarName, ExprSingle defaultReturn) { this.switchExpr = switchExpr; this.caseList = caseList; this.defaultVarName = defaultVarName; this.defaultReturn = defaultReturn; }
internal override ExprSingle CompileCore (XQueryASTCompiler compiler) { first = first.Compile (compiler); next = next.Compile (compiler); return this; }
public PathSlash2Expr (ExprSingle first, ExprSingle next) : base (first, next) { }
public GroupExpr (ExprSingle left, ExprSingle right, AggregationType aggrType) : base (left, right) { this.aggrType = aggrType; }
public PathStepExpr (ExprSingle first, ExprSingle next) { this.first = first; this.next = next; }
public MinusExpr (ExprSingle expr) { this.expr = expr; }
public ArithmeticOperationExpr (ExprSingle left, ExprSingle right, ArithmeticOperator oper) : base (left, right) { this.oper = oper; }
public RangeExpr (ExprSingle left, ExprSingle right) : base (left, right) { }
public QuantifiedExpr (bool every, QuantifiedExprBodyList body, ExprSingle satisfies) { this.every = every; this.body = body; this.satisfies = satisfies; }
public FilterStepExpr (ExprSingle expr, ExprSequence predicate) { this.expr = expr; this.predicate = predicate; }
internal override ExprSingle CompileCore (XQueryASTCompiler compiler) { Satisfies = Satisfies.Compile (compiler); for (int i = 0; i < BodyList.Count; i++) { BodyList [i].Expression = BodyList [i].Expression.Compile (compiler); if (BodyList [i].Type != null) compiler.CheckType (BodyList [i].Expression, BodyList [i].Type); } return this; }
public FLWORExpr (ForLetClauseCollection forlet, ExprSequence whereClause, OrderSpecList orderBy, ExprSingle ret) { this.fl = forlet; if (whereClause != null) this.whereClause = new ParenthesizedExpr (whereClause); this.orderBy = orderBy; this.ret = ret; }
public QuantifiedExprBody (XmlQualifiedName varName, SequenceType type, ExprSingle expr) { this.varName = varName; this.type = type ; this.expr = expr; }
internal override ExprSingle CompileCore (XQueryASTCompiler compiler) { foreach (ForLetClause flc in ForLetClauses) { foreach (ForLetSingleBody flsb in flc) { flsb.Expression = flsb.Expression.Compile (compiler); if (flsb.ReturnType != null) compiler.CheckType (flsb.Expression, flsb.ReturnType); } } if (WhereClause != null) whereClause = whereClause.Compile (compiler); if (OrderBy != null) foreach (OrderSpec os in OrderBy) os.Expression = os.Expression.Compile (compiler); ReturnExpr = ReturnExpr.Compile (compiler); return this; }
internal override ExprSingle CompileCore (XQueryASTCompiler compiler) { for (int i = 0; i < SwitchExpr.Count; i++) SwitchExpr [i] = SwitchExpr [i].Compile (compiler); foreach (CaseClause cc in Cases) cc.Expr = cc.Expr.Compile (compiler); DefaultReturn = DefaultReturn.Compile (compiler); return this; }
public OrderSpec (ExprSingle expr, OrderModifier modifier) { this.expr = expr; this.mod = modifier; }
public IfExpr (ExprSequence condition, ExprSingle trueExpr, ExprSingle falseExpr) { this.condition = new ParenthesizedExpr (condition); this.trueExpr = trueExpr; this.falseExpr = falseExpr; }
public void Add (ExprSingle expr) { List.Add (expr); }
protected BinaryOperationExpr (ExprSingle left, ExprSingle right) { this.left = left; this.right = right; }
public ForSingleBody (XmlQualifiedName varName, SequenceType type, XmlQualifiedName positionalVar, ExprSingle expr) : base (varName, type, expr) { this.positionalVar = positionalVar; }
public AndExpr (ExprSingle left, ExprSingle right) : base (left, right) { }
public LetSingleBody (XmlQualifiedName varName, SequenceType type, ExprSingle expr) : base (varName, type, 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 CastExpr (ExprSingle expr, XmlTypeCode atomicType, bool optional) : base (expr, atomicType, optional) { }