/// <summary>
/// Creates a new <see cref="AssignmentExpression"/> instance
/// with the <paramref name="leftSide"/>, <paramref name="operation"/>
/// and <paramref name="rightSide"/> provided.
/// </summary>
/// <param name="leftSide">The <see cref="INaryOperandExpression"/> which makes up the
/// left operand.</param>
/// <param name="operation">The <see cref="AssignmentOperation"/> which indicates the operation
/// the current <see cref="AssignmentExpression"/> represents.</param>
/// <param name="rightSide">The <see cref="INaryOperandExpression"/> which makes up the
/// right operand.</param>
/// <exception cref="System.ArgumentNullException">thrown when <paramref name="leftSide"/> or
/// <paramref name="rightSide"/> is null.</exception>
/// <exception cref="System.ArgumentOutOfRangeException">thrown when <paramref name="operation"/>
/// is a value not within the <see cref="AssignmentOperation"/> enumeration; or when
/// <paramref name="operation"/> is <see cref="AssignmentOperation.Term"/>.</exception>
public AssignmentExpression(INaryOperandExpression leftSide, AssignmentOperation operation, INaryOperandExpression rightSide)
{
switch (operation)
{
case AssignmentOperation.SimpleAssign:
case AssignmentOperation.MultiplicationAssign:
case AssignmentOperation.DivisionAssign:
case AssignmentOperation.ModulusAssign:
case AssignmentOperation.AddAssign:
case AssignmentOperation.SubtractionAssign:
case AssignmentOperation.LeftShiftAssign:
case AssignmentOperation.RightShiftAssign:
case AssignmentOperation.BitwiseAndAssign:
case AssignmentOperation.BitwiseOrAssign:
case AssignmentOperation.BitwiseExclusiveOrAssign:
break;
case AssignmentOperation.Term:
default:
throw new ArgumentOutOfRangeException("operation");
}
this.operation = operation;
this.LeftSide = leftSide;
this.RightSide = rightSide;
}
public static IYieldReturnStatement YieldReturn(this IBlockStatementParent blockParent, INaryOperandExpression returnValue)
{
return(blockParent.YieldReturn((IExpression)returnValue));
}
public static IReturnStatement Return(this IBlockStatementParent blockParent, INaryOperandExpression returnValue)
{
return(blockParent.Return(returnValue));
}
public IExpression BinaryOperation(INaryOperandExpression left, BinaryOperationKind op, INaryOperandExpression right)
{
switch (op)
{
case BinaryOperationKind.Assign:
return(left.Add(right));
case BinaryOperationKind.AssignMultiply:
return(new AssignmentExpression(left, AssignmentOperation.MultiplicationAssign, right));
case BinaryOperationKind.AssignModulus:
return(new AssignmentExpression(left, AssignmentOperation.ModulusAssign, right));
case BinaryOperationKind.AssignDivide:
return(new AssignmentExpression(left, AssignmentOperation.DivisionAssign, right));
case BinaryOperationKind.AssignAdd:
return(new AssignmentExpression(left, AssignmentOperation.AddAssign, right));
case BinaryOperationKind.AssignSubtract:
return(new AssignmentExpression(left, AssignmentOperation.SubtractionAssign, right));
case BinaryOperationKind.AssignLeftShift:
return(new AssignmentExpression(left, AssignmentOperation.LeftShiftAssign, right));
case BinaryOperationKind.AssignRightShift:
return(new AssignmentExpression(left, AssignmentOperation.RightShiftAssign, right));
case BinaryOperationKind.AssignBitwiseAnd:
return(new AssignmentExpression(left, AssignmentOperation.BitwiseAndAssign, right));
case BinaryOperationKind.AssignBitwiseOr:
return(new AssignmentExpression(left, AssignmentOperation.BitwiseOrAssign, right));
case BinaryOperationKind.AssignBitwiseExclusiveOr:
return(new AssignmentExpression(left, AssignmentOperation.BitwiseExclusiveOrAssign, right));
case BinaryOperationKind.LogicalOr:
return(left.LogicalOr(right));
case BinaryOperationKind.LogicalAnd:
return(left.LogicalAnd(right));
case BinaryOperationKind.BitwiseOr:
return(left.BitwiseOr(right));
case BinaryOperationKind.BitwiseExclusiveOr:
return(left.BitwiseXOr(right));
case BinaryOperationKind.BitwiseAnd:
return(left.BitwiseAnd(right));
case BinaryOperationKind.Inequality:
return(left.InequalTo(right));
case BinaryOperationKind.Equality:
return(left.EqualTo(right));
case BinaryOperationKind.LessThan:
return(left.LessThan(right));
case BinaryOperationKind.LessThanOrEqualTo:
return(left.LessThanOrEqualTo(right));
case BinaryOperationKind.GreaterThan:
return(left.GreaterThan(right));
case BinaryOperationKind.GreaterThanOrEqualTo:
return(left.GreaterThanOrEqualTo(right));
case BinaryOperationKind.LeftShift:
return(left.Shift(CSharpShiftOperation.LeftShift, right));
case BinaryOperationKind.RightShift:
return(left.Shift(CSharpShiftOperation.RightShift, right));
case BinaryOperationKind.Add:
return(left.Add(right));
case BinaryOperationKind.Subtract:
return(left.Subtract(right));
case BinaryOperationKind.Multiply:
return(left.Multiply(right));
case BinaryOperationKind.Modulus:
return(left.Modulus(right));
case BinaryOperationKind.StrictDivision:
return(left.Division(right));
case BinaryOperationKind.IntegerDivision:
case BinaryOperationKind.FlexibleDivision:
throw new NotSupportedException();
default:
throw new ArgumentOutOfRangeException("op");
}
}
/// <summary>
/// Creates a new non-operational <see cref="AssignmentExpression"/> with the <paramref name="term"/>
/// provided.
/// </summary>
/// <param name="term">The term the non-operational <see cref="AssignmentExpression"/>
/// points to.</param>
public AssignmentExpression(INaryOperandExpression term)
: base()
{
operation = AssignmentOperation.Term;
this.LeftSide = term;
}
