/// <summary>
/// Visits the specified not equality.
/// </summary>
/// <param name="notEquality">The not equality.</param>
/// <returns></returns>
protected virtual IExpression DeepCopy(NotEquality notEquality)
{
return this.DeepCopy((BinaryOperation)notEquality);
}
private Statement ParseUnaryConditionalBranch(IOperation currentOperation)
{
Expression condition = this.PopOperandStack();
var castIfPossible = condition as CastIfPossible;
if (castIfPossible != null) {
condition = new CheckIfInstance() {
Locations = castIfPossible.Locations,
Operand = castIfPossible.ValueToCast,
TypeToCheck = castIfPossible.TargetType,
};
} else if (condition.Type != Dummy.TypeReference && condition.Type.TypeCode != PrimitiveTypeCode.Boolean) {
var defaultValue = new DefaultValue() { DefaultValueType = condition.Type, Type = condition.Type };
condition = new NotEquality() { LeftOperand = condition, RightOperand = defaultValue };
}
condition.Type = this.platformType.SystemBoolean;
GotoStatement gotoStatement = MakeGoto(currentOperation);
ConditionalStatement ifStatement = new ConditionalStatement();
ifStatement.Condition = condition;
switch (currentOperation.OperationCode) {
case OperationCode.Brfalse:
case OperationCode.Brfalse_S:
ifStatement.TrueBranch = new EmptyStatement();
ifStatement.FalseBranch = gotoStatement;
break;
case OperationCode.Brtrue:
case OperationCode.Brtrue_S:
default:
ifStatement.TrueBranch = gotoStatement;
ifStatement.FalseBranch = new EmptyStatement();
break;
}
return ifStatement;
}
private static IExpression InvertBinaryOperation(IBinaryOperation binOp) {
Contract.Requires(binOp != null);
Contract.Ensures(Contract.Result<IExpression>() != null);
BinaryOperation/*?*/ result = null;
if (binOp is IEquality && binOp.LeftOperand.Type.TypeCode != PrimitiveTypeCode.Float32 && binOp.LeftOperand.Type.TypeCode != PrimitiveTypeCode.Float64)
result = new NotEquality();
else if (binOp is INotEquality && binOp.LeftOperand.Type.TypeCode != PrimitiveTypeCode.Float32 && binOp.LeftOperand.Type.TypeCode != PrimitiveTypeCode.Float64)
result = new Equality();
else if (binOp is ILessThan)
result = new GreaterThanOrEqual() { IsUnsignedOrUnordered = KeepUnsignedButInvertUnordered(((ILessThan)binOp).IsUnsignedOrUnordered, binOp) };
else if (binOp is ILessThanOrEqual)
result = new GreaterThan() { IsUnsignedOrUnordered = KeepUnsignedButInvertUnordered(((ILessThanOrEqual)binOp).IsUnsignedOrUnordered, binOp) };
else if (binOp is IGreaterThan)
result = new LessThanOrEqual() { IsUnsignedOrUnordered = KeepUnsignedButInvertUnordered(((IGreaterThan)binOp).IsUnsignedOrUnordered, binOp) };
else if (binOp is IGreaterThanOrEqual)
result = new LessThan() { IsUnsignedOrUnordered = KeepUnsignedButInvertUnordered(((IGreaterThanOrEqual)binOp).IsUnsignedOrUnordered, binOp) };
if (result != null) {
result.LeftOperand = binOp.LeftOperand;
result.RightOperand = binOp.RightOperand;
result.Type = binOp.Type;
result.Locations.AddRange(binOp.Locations);
return result;
}
LogicalNot logicalNot = new LogicalNot();
logicalNot.Operand = binOp;
logicalNot.Type = binOp.Type;
logicalNot.Locations.AddRange(binOp.Locations);
return logicalNot;
}
/// <summary>
/// Visits the specified not equality.
/// </summary>
/// <param name="notEquality">The not equality.</param>
public override void Visit(INotEquality notEquality)
{
NotEquality mutableNotEquality = new NotEquality(notEquality);
this.resultExpression = this.myCodeCopier.DeepCopy(mutableNotEquality);
}
private static IExpression ConvertToBoolean(IExpression expression) {
Contract.Requires(expression != null);
Contract.Ensures(Contract.Result<IExpression>() != null);
IPlatformType platformType = expression.Type.PlatformType;
var cc = expression as CompileTimeConstant;
if (cc != null && TypeHelper.IsPrimitiveInteger(cc.Type)) {
cc.Value = !ExpressionHelper.IsIntegralZero(cc);
cc.Type = platformType.SystemBoolean;
return cc;
}
var conditional = expression as Conditional;
if (conditional != null) {
conditional.ResultIfTrue = ConvertToBoolean(conditional.ResultIfTrue);
conditional.ResultIfFalse = ConvertToBoolean(conditional.ResultIfFalse);
conditional.Type = platformType.SystemBoolean;
return conditional;
}
object/*?*/ val = null;
ITypeReference type = platformType.SystemObject;
ITypeReference expressionType = expression.Type;
IExpression rightOperand = null; // zero or null, but has to be type-specific
switch (expressionType.TypeCode) {
case PrimitiveTypeCode.Boolean: {
var addrDeref = expression as AddressDereference;
Conversion conversion;
IManagedPointerTypeReference mgdPtr;
if (addrDeref != null && (conversion = addrDeref.Address as Conversion) != null &&
(mgdPtr = conversion.ValueToConvert.Type as IManagedPointerTypeReference) != null) {
expressionType = mgdPtr.TargetType;
addrDeref.Address = conversion.ValueToConvert;
addrDeref.Type = expressionType;
expression = addrDeref;
goto default;
}
return expression;
}
case PrimitiveTypeCode.Char: val = (char)0; type = platformType.SystemChar; break;
case PrimitiveTypeCode.Float32: val = (float)0; type = platformType.SystemFloat32; break;
case PrimitiveTypeCode.Float64: val = (double)0; type = platformType.SystemFloat64; break;
case PrimitiveTypeCode.Int16: val = (short)0; type = platformType.SystemInt16; break;
case PrimitiveTypeCode.Int32: val = (int)0; type = platformType.SystemInt32; break;
case PrimitiveTypeCode.Int64: val = (long)0; type = platformType.SystemInt64; break;
case PrimitiveTypeCode.Int8: val = (sbyte)0; type = platformType.SystemInt8; break;
case PrimitiveTypeCode.IntPtr: val = IntPtr.Zero; type = platformType.SystemIntPtr; break;
case PrimitiveTypeCode.UInt16: val = (ushort)0; type = platformType.SystemUInt16; break;
case PrimitiveTypeCode.UInt32: val = (uint)0; type = platformType.SystemUInt32; break;
case PrimitiveTypeCode.UInt64: val = (ulong)0; type = platformType.SystemUInt64; break;
case PrimitiveTypeCode.UInt8: val = (byte)0; type = platformType.SystemUInt8; break;
case PrimitiveTypeCode.UIntPtr: val = UIntPtr.Zero; type = platformType.SystemUIntPtr; break;
default:
rightOperand = new DefaultValue() {
DefaultValueType = expressionType,
Type = expressionType,
};
break;
}
if (rightOperand == null) {
rightOperand = new CompileTimeConstant() {
Value = val,
Type = type,
};
}
NotEquality result = new NotEquality() {
LeftOperand = expression,
RightOperand = rightOperand,
Type = platformType.SystemBoolean,
};
return result;
}
public override IExpression Visit(NotEquality notEquality)
{
base.Visit(notEquality);
var cc1 = notEquality.LeftOperand as CompileTimeConstant;
var cc2 = notEquality.RightOperand as CompileTimeConstant;
if (cc1 != null && cc2 != null) {
if (cc1.Type.TypeCode == PrimitiveTypeCode.Int32 && cc2.Type.TypeCode == PrimitiveTypeCode.Int32)
return new CompileTimeConstant() { Value = ((int)cc1.Value) != ((int)cc2.Value), Type = notEquality.Type };
}
return notEquality;
}
/// <summary>
/// Visits the specified not equality.
/// </summary>
/// <param name="notEquality">The not equality.</param>
/// <returns></returns>
public virtual IExpression Visit(NotEquality notEquality)
{
return this.Visit((BinaryOperation)notEquality);
}
/// <summary>
/// Rewrites the children of the given not equality expression.
/// </summary>
public virtual void RewriteChildren(NotEquality notEquality)
{
this.RewriteChildren((BinaryOperation)notEquality);
}
/// <summary>
/// Visits the specified not equality.
/// </summary>
/// <param name="notEquality">The not equality.</param>
public override void Visit(INotEquality notEquality)
{
NotEquality mutableNotEquality = notEquality as NotEquality;
if (alwaysMakeACopy || mutableNotEquality == null) mutableNotEquality = new NotEquality(notEquality);
this.resultExpression = this.myCodeMutator.Visit(mutableNotEquality);
}
