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