/// <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; }