/// <inheritdoc />
public override void VisitIntervalIntegerValue(IntegerIntervalValue value)
{
// When comparing, both operands are converted to boolean
switch (operation)
{
case Operations.BitOr:
case Operations.BitXor:
result = value;
break;
case Operations.Mod:
result = ModuloOperation.Modulo(flow, TypeConversion.ToInteger(leftOperand), value);
break;
default:
result = ArithmeticOperation.Arithmetic(flow, operation,
TypeConversion.ToInteger(leftOperand), value);
if (result != null)
{
break;
}
base.VisitIntervalIntegerValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitIntervalIntegerValue(IntegerIntervalValue value)
{
switch (operation)
{
case Operations.Identical:
result = Comparison.Equal(OutSet, leftOperand, value);
break;
case Operations.NotIdentical:
result = Comparison.NotEqual(OutSet, leftOperand, value);
break;
case Operations.Mod:
result = ModuloOperation.Modulo(flow, leftOperand, value);
break;
default:
result = Comparison.IntervalCompare(OutSet, operation, leftOperand, value);
if (result != null)
{
break;
}
result = ArithmeticOperation.Arithmetic(flow, operation, leftOperand, value);
if (result != null)
{
break;
}
base.VisitIntervalIntegerValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitIntervalIntegerValue(IntegerIntervalValue value)
{
switch (operation)
{
case Operations.Identical:
result = OutSet.CreateBool(false);
break;
case Operations.NotIdentical:
result = OutSet.CreateBool(true);
break;
case Operations.Mod:
result = ModuloOperation.Modulo(flow, leftOperand, value);
break;
default:
result = Comparison.IntervalCompare(OutSet, operation, leftOperand,
TypeConversion.ToFloatInterval(OutSet, value));
if (result != null)
{
break;
}
result = ArithmeticOperation.Arithmetic(flow, operation, leftOperand, value);
if (result != null)
{
break;
}
base.VisitIntervalIntegerValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitIntervalIntegerValue(IntegerIntervalValue value)
{
switch (operation)
{
case Operations.Mod:
result = ModuloOperation.AbstractModulo(flow, value);
break;
default:
result = Comparison.LeftAbstractBooleanCompare(OutSet, operation, value);
if (result != null)
{
break;
}
result = ArithmeticOperation.LeftAbstractBooleanArithmetic(flow, operation, value);
if (result != null)
{
break;
}
base.VisitIntervalIntegerValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitIntervalIntegerValue(IntegerIntervalValue value)
{
switch (operation)
{
case Operations.Mod:
SetWarning("Object cannot be converted to integer by modulo operation",
AnalysisWarningCause.OBJECT_CONVERTED_TO_INTEGER);
result = ModuloOperation.AbstractModulo(flow, value);
break;
default:
result = ArithmeticOperation.LeftAbstractArithmetic(flow, operation, value);
if (result != null)
{
break;
}
result = LogicalOperation.Logical(OutSet, operation,
TypeConversion.ToBoolean(leftOperand), value);
if (result != null)
{
break;
}
base.VisitIntervalIntegerValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitIntervalIntegerValue(IntegerIntervalValue value)
{
if (isIncrement)
{
if (value.End < int.MaxValue)
{
result = OutSet.CreateIntegerInterval(value.Start + 1, value.End + 1);
}
else
{
result = OutSet.CreateFloatInterval(TypeConversion.ToFloat(value.Start) + 1.0,
TypeConversion.ToFloat(value.End) + 1.0);
}
}
else
{
if (value.Start > int.MinValue)
{
result = OutSet.CreateIntegerInterval(value.Start - 1, value.End - 1);
}
else
{
result = OutSet.CreateFloatInterval(TypeConversion.ToFloat(value.Start) - 1.0,
TypeConversion.ToFloat(value.End) - 1.0);
}
}
}
/// <inheritdoc />
public override void VisitIntervalIntegerValue(IntegerIntervalValue value)
{
switch (operation)
{
case Operations.Mod:
result = ModuloOperation.Modulo(flow,
TypeConversion.ToInteger(leftOperand.Value), value);
break;
default:
var leftInteger = TypeConversion.ToInteger(leftOperand.Value);
result = Comparison.IntervalCompare(OutSet, operation, leftInteger, value);
if (result != null)
{
break;
}
result = ArithmeticOperation.Arithmetic(flow, operation, leftInteger, value);
if (result != null)
{
break;
}
result = LogicalOperation.Logical(OutSet, operation, leftOperand.Value, value);
if (result != null)
{
break;
}
base.VisitIntervalIntegerValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitIntervalIntegerValue(IntegerIntervalValue value)
{
switch (operation)
{
case Operations.Mod:
result = ModuloOperation.Modulo(flow, leftOperand.Value, value);
break;
default:
result = LogicalOperation.Logical(OutSet, operation,
TypeConversion.ToBoolean(leftOperand.Value), value);
if (result != null)
{
break;
}
int integerValue;
double floatValue;
bool isInteger;
TypeConversion.TryConvertToNumber(leftOperand.Value, true,
out integerValue, out floatValue, out isInteger);
if (isInteger)
{
result = Comparison.IntervalCompare(OutSet, operation, integerValue, value);
if (result != null)
{
break;
}
result = ArithmeticOperation.Arithmetic(flow, operation, integerValue, value);
if (result != null)
{
break;
}
}
else
{
var floatInterval = TypeConversion.ToFloatInterval(OutSet, value);
result = Comparison.IntervalCompare(OutSet, operation, floatValue, floatInterval);
if (result != null)
{
break;
}
result = ArithmeticOperation.Arithmetic(flow, operation, floatValue, floatInterval);
if (result != null)
{
break;
}
}
base.VisitIntervalIntegerValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitIntervalIntegerValue(IntegerIntervalValue value)
{
result = LogicalOperation.Logical(OutSet, operation, leftOperand, value);
if (result != null)
{
return;
}
base.VisitIntervalIntegerValue(value);
}
/// <inheritdoc />
public override void VisitIntervalIntegerValue(IntegerIntervalValue value)
{
switch (operation)
{
case Operations.Mod:
result = ModuloOperation.AbstractModulo(flow, value);
break;
default:
base.VisitIntervalIntegerValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitIntervalIntegerValue(IntegerIntervalValue value)
{
switch (operation)
{
case Operations.Mod:
// Ommitted warning message that object cannot be converted to integer
result = ModuloOperation.AbstractModulo(flow, value);
break;
default:
base.VisitIntervalIntegerValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitIntervalIntegerValue(IntegerIntervalValue value)
{
if (value.Start == value.End)
{
VisitIntegerValue(OutSet.CreateInt(value.Start));
return;
}
switch (operation)
{
case Operations.Minus:
// Result of arithmetic negation can overflow
if ((value.Start == 0) || ((-value.Start) != 0))
{
result = OutSet.CreateIntegerInterval(-value.End, -value.Start);
}
else
{
// <seealso cref="UnaryOperationEvaluator.VisitIntegerValue" />
result = OutSet.CreateFloatInterval(-TypeConversion.ToFloat(value.End),
-TypeConversion.ToFloat(value.Start));
}
break;
case Operations.BitNegation:
result = OutSet.CreateIntegerInterval(~value.End, ~value.Start);
break;
case Operations.Int32Cast:
result = value;
break;
case Operations.FloatCast:
case Operations.DoubleCast:
result = OutSet.CreateFloatInterval(TypeConversion.ToFloat(value.Start),
TypeConversion.ToFloat(value.End));
break;
default:
base.VisitIntervalIntegerValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitIntervalIntegerValue(IntegerIntervalValue value)
{
switch (operation)
{
case Operations.Mod:
result = ModuloOperation.AbstractModulo(flow, value);
break;
default:
result = LogicalOperation.AbstractLogical(OutSet, operation, value);
if (result != null)
{
break;
}
base.VisitIntervalIntegerValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitIntervalIntegerValue(IntegerIntervalValue value)
{
switch (operation)
{
case Operations.Mod:
result = ModuloOperation.Modulo(flow,
TypeConversion.ToNativeInteger(Snapshot, leftOperand), value);
break;
default:
result = LogicalOperation.Logical(OutSet, operation,
TypeConversion.ToNativeBoolean(Snapshot, leftOperand), value);
if (result != null)
{
break;
}
base.VisitIntervalIntegerValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitIntervalIntegerValue(IntegerIntervalValue value)
{
switch (operation)
{
case Operations.Identical:
result = OutSet.CreateBool(false);
break;
case Operations.NotIdentical:
result = OutSet.CreateBool(true);
break;
case Operations.Mod:
result = ModuloOperation.AbstractModulo(flow, value);
break;
default:
base.VisitIntervalIntegerValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitIntervalIntegerValue(IntegerIntervalValue value)
{
switch (operation)
{
case Operations.Identical:
case Operations.NotIdentical:
result = OutSet.AnyBooleanValue;
break;
case Operations.Mod:
result = ModuloOperation.AbstractModulo(flow, value);
break;
default:
result = ArithmeticOperation.LeftAbstractArithmetic(flow, operation, value);
if (result != null)
{
break;
}
base.VisitIntervalIntegerValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitIntervalIntegerValue(IntegerIntervalValue value)
{
Max = Math.Max(Max, value.End);
}
/// <inheritdoc />
public override void VisitIntervalLongintValue(LongintIntervalValue value)
{
Result = snapshot.CreateIntegerInterval((int)value.Start, (int)value.End);
}
/// <inheritdoc />
public override void VisitIntervalIntegerValue(IntegerIntervalValue value)
{
Result = value;
}
/// <inheritdoc />
public override void VisitIntervalIntegerValue(IntegerIntervalValue value)
{
Result = snapshot.CreateFloatInterval(value.Start, value.End);
}
/// <inheritdoc />
public override void VisitIntervalIntegerValue(IntegerIntervalValue value)
{
containsInt = true;
minInt = Math.Min(Math.Min(minInt, value.Start), value.End);
maxInt = Math.Max(Math.Max(maxInt, value.Start), value.End);
}
/// <inheritdoc />
public override void VisitIntervalIntegerValue(IntegerIntervalValue value)
{
numberFound();
}
/// <inheritdoc />
public override void VisitIntervalIntegerValue(IntegerIntervalValue value)
{
integerIntervalVisitor.SetLeftOperand(value);
visitor = integerIntervalVisitor;
}
