public static Expression ModuloChecked(Expression left, Expression right)
{
return new ArithmeticExpression (left, right, ArithmeticKind.Modulo);
}
public static Statement Loop(Expression cond, StatementBlock block)
{
throw new NotImplementedException ();
}
public static Statement Switch(Expression cond, SwitchCase [] cases)
{
throw new NotImplementedException ();
}
public static VariableDeclarationStatement DeclareVariable(TypeInfo type, string name, Expression initializer)
{
return new VariableDeclarationStatement (type, name, initializer);
}
public static Statement IfThen(Expression cond, StatementBlock trueBlock)
{
return new IfStatement (cond, trueBlock, null);
}
public ParenthesizedExpression(Expression exp)
{
Body = exp;
}
public ReturnStatement(Expression value)
{
Value = value;
}
public static Expression OrElse(Expression left, Expression right)
{
return new LogicalOperationExpression (left, right, LogicalOperationKind.OrElse);
}
public static Expression Parenthesized(Expression exp)
{
return new ParenthesizedExpression (exp);
}
public static Expression Or(Expression left, Expression right)
{
return new ArithmeticExpression (left, right, ArithmeticKind.BitwiseOr);
}
public ArithmeticExpression(Expression left, Expression right, ArithmeticKind kind)
{
Left = left;
Right = right;
Kind = kind;
}
public static Expression NotEqual(Expression left, Expression right)
{
return new ComparisonExpression (left, right, ComparisonKind.NotEqual);
}
public static Expression Not(Expression operand)
{
if (operand == null)
throw new ArgumentNullException ("operand");
return new LogicalNotExpression (operand);
}
public static Expression MultiplyChecked(Expression left, Expression right)
{
return new ArithmeticExpression (left, right, ArithmeticKind.Multiply);
}
public LogicalNotExpression(Expression value)
{
if (value == null)
throw new ArgumentNullException ("value");
Value = value;
}
public static Expression PropertyOrField(Expression obj, string memberName)
{
return new FieldAccessExpression (obj, memberName);
}
public LogicalOperationExpression(Expression left, Expression right, LogicalOperationKind kind)
{
Left = left;
Right = right;
Kind = kind;
}
public static Expression RightShift(Expression left, Expression right)
{
throw new NotImplementedException ();
}
public ArrayAccessExpression(Expression array, Expression index)
{
Array = array;
Index = index;
}
public static Expression SubtractChecked(Expression left, Expression right)
{
return new ArithmeticExpression (left, right, ArithmeticKind.Subtract);
}
public static Statement CallExpression(Expression exp)
{
return new CallableExpressionStatement (exp);
}
public FieldAccessExpression(Expression target, string memberName)
{
Target = target;
MemberName = memberName;
}
public static Statement For(List<Statement> init,
Expression cond,
Statement cont,
StatementBlock body)
{
return new ForStatement (init, cond, cont, body);
}
public ForStatement(List<Statement> init,
Expression cond,
Statement cont,
StatementBlock body)
{
Initializers = init;
Condition = cond;
Continuer = cont;
Body = body;
}
// It does not use StatementBlock to handle else-if statements as IfStatement (i.e. IfStatement(trueBlock, IfStatement(elseIfTrue, finalElseBlock)) etc.)
public static Statement IfThenElse(Expression cond, Statement trueBlock, Statement falseBlock)
{
return new IfStatement (cond, trueBlock, falseBlock);
}
public FunctionCallExpression(Expression obj, string name, List<Expression> args)
{
Target = obj;
Name = name;
Arguments = args;
}
public static Statement Return(Expression value)
{
return new ReturnStatement (value);
}
public IfStatement(Expression cond, Statement trueBlock, Statement falseBlock)
{
Condition = cond;
TrueBlock = trueBlock;
FalseBlock = falseBlock;
}
public VariableDeclarationStatement(TypeInfo type, string name, Expression initializer)
{
Type = type;
Name = name;
Initializer = initializer;
}
public static Expression LessThanOrEqual(Expression left, Expression right)
{
return new ComparisonExpression (left, right, ComparisonKind.LessThanEqual);
}