/// <inheritdoc />
public override void VisitAnyResourceValue(AnyResourceValue value)
{
var rightBoolean = TypeConversion.ToBoolean(value);
result = Comparison.Compare(OutSet, operation, leftOperand.Value, rightBoolean);
if (result != null)
{
return;
}
result = LogicalOperation.Logical(OutSet, operation, leftOperand.Value, rightBoolean);
if (result != null)
{
return;
}
result = ArithmeticOperation.RightAbstractArithmetic(flow, operation,
TypeConversion.ToInteger(leftOperand.Value));
if (result != null)
{
// Arithmetic with resources is nonsence
return;
}
base.VisitAnyResourceValue(value);
}
/// <inheritdoc />
public override void VisitIntervalFloatValue(FloatIntervalValue 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.VisitIntervalFloatValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitBooleanValue(BooleanValue value)
{
switch (operation)
{
case Operations.Identical:
result = OutSet.CreateBool(false);
break;
case Operations.NotIdentical:
result = OutSet.CreateBool(true);
break;
case Operations.Mod:
result = ModuloOperation.ModuloByBooleanValue(flow, value.Value);
break;
default:
result = Comparison.IntervalCompare(OutSet, operation, leftOperand, value.Value);
if (result != null)
{
break;
}
result = LogicalOperation.Logical(OutSet, operation, leftOperand, value.Value);
if (result != null)
{
break;
}
base.VisitBooleanValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitAnyObjectValue(AnyObjectValue value)
{
var rightBoolean = TypeConversion.ToBoolean(value);
result = Comparison.Compare(OutSet, operation, leftOperand.Value, rightBoolean);
if (result != null)
{
return;
}
result = ArithmeticOperation.RightAbstractArithmetic(flow, operation,
TypeConversion.ToInteger(leftOperand.Value));
if (result != null)
{
SetWarning("Object cannot be converted to integer by arithmetic operation",
AnalysisWarningCause.OBJECT_CONVERTED_TO_INTEGER);
return;
}
result = LogicalOperation.Logical(OutSet, operation, leftOperand.Value, rightBoolean);
if (result != null)
{
return;
}
base.VisitAnyObjectValue(value);
}
/// <inheritdoc />
public override void VisitBooleanValue(BooleanValue value)
{
switch (operation)
{
case Operations.Mod:
result = ModuloOperation.ModuloByBooleanValue(flow, value.Value);
break;
default:
var leftBoolean = TypeConversion.ToNativeBoolean(Snapshot, leftOperand);
result = Comparison.Compare(OutSet, operation, leftBoolean, value.Value);
if (result != null)
{
break;
}
result = LogicalOperation.Logical(OutSet, operation, leftBoolean, value.Value);
if (result != null)
{
break;
}
result = BitwiseOperation.Bitwise(OutSet, operation,
TypeConversion.ToNativeInteger(Snapshot, leftOperand),
TypeConversion.ToInteger(value.Value));
if (result != null)
{
break;
}
base.VisitBooleanValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitIntervalFloatValue(FloatIntervalValue value)
{
switch (operation)
{
case Operations.Mod:
result = ModuloOperation.Modulo(flow,
TypeConversion.ToInteger(leftOperand.Value), value);
break;
default:
var leftFloat = TypeConversion.ToFloat(leftOperand.Value);
result = Comparison.IntervalCompare(OutSet, operation, leftFloat, value);
if (result != null)
{
break;
}
result = ArithmeticOperation.Arithmetic(flow, operation, leftFloat, value);
if (result != null)
{
break;
}
result = LogicalOperation.Logical(OutSet, operation, leftOperand.Value, value);
if (result != null)
{
break;
}
base.VisitIntervalFloatValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitBooleanValue(BooleanValue value)
{
var leftBoolean = TypeConversion.ToBoolean(leftOperand.Value);
result = Comparison.Compare(OutSet, operation, leftBoolean, value.Value);
if (result != null)
{
return;
}
var rightInteger = TypeConversion.ToInteger(value.Value);
result = ArithmeticOperation.Arithmetic(flow, operation,
leftOperand.Value, rightInteger);
if (result != null)
{
return;
}
result = LogicalOperation.Logical(OutSet, operation, leftBoolean, value.Value);
if (result != null)
{
return;
}
result = BitwiseOperation.Bitwise(OutSet, operation, leftOperand.Value, rightInteger);
if (result != null)
{
return;
}
base.VisitBooleanValue(value);
}
/// <inheritdoc />
public override void VisitAssociativeArray(AssociativeArray value)
{
switch (operation)
{
case Operations.Mod:
result = ModuloOperation.Modulo(flow, leftOperand.Value,
TypeConversion.ToNativeInteger(Snapshot, value));
break;
default:
result = LogicalOperation.Logical(OutSet, operation,
TypeConversion.ToBoolean(leftOperand.Value),
TypeConversion.ToNativeBoolean(Snapshot, value));
if (result != null)
{
break;
}
result = BitwiseOperation.Bitwise(OutSet, operation, leftOperand.Value,
TypeConversion.ToNativeInteger(Snapshot, value));
if (result != null)
{
break;
}
base.VisitAssociativeArray(value);
break;
}
}
/// <inheritdoc />
public override void VisitAnyResourceValue(AnyResourceValue value)
{
result = Comparison.AbstractCompare(OutSet, operation);
if (result != null)
{
// Comapring of resource and string makes no sence.
return;
}
result = LogicalOperation.Logical(OutSet, operation,
TypeConversion.ToBoolean(leftOperand.Value), TypeConversion.ToBoolean(value));
if (result != null)
{
return;
}
int integerValue;
double floatValue;
bool isInteger;
TypeConversion.TryConvertToNumber(leftOperand.Value, true,
out integerValue, out floatValue, out isInteger);
result = isInteger
? ArithmeticOperation.RightAbstractArithmetic(flow, operation, integerValue)
: ArithmeticOperation.RightAbstractArithmetic(flow, operation, floatValue);
if (result != null)
{
// Arithmetic with resources is nonsence
return;
}
base.VisitAnyResourceValue(value);
}
/// <inheritdoc />
public override void VisitStringValue(StringValue value)
{
switch (operation)
{
case Operations.Mod:
result = ModuloOperation.Modulo(flow,
TypeConversion.ToNativeInteger(Snapshot, leftOperand), value.Value);
break;
default:
result = Comparison.LeftAlwaysGreater(OutSet, operation);
if (result != null)
{
break;
}
var leftBoolean = TypeConversion.ToNativeBoolean(Snapshot, leftOperand);
var rightBoolean = TypeConversion.ToBoolean(value.Value);
result = LogicalOperation.Logical(OutSet, operation, leftBoolean, rightBoolean);
if (result != null)
{
break;
}
result = BitwiseOperation.Bitwise(OutSet, operation,
TypeConversion.ToNativeInteger(Snapshot, leftOperand), value.Value);
if (result == null)
{
base.VisitStringValue(value);
}
break;
}
}
/// <inheritdoc />
public override void VisitBooleanValue(BooleanValue value)
{
switch (operation)
{
case Operations.Mod:
result = ModuloOperation.ModuloByBooleanValue(flow, value.Value);
break;
default:
var leftBoolean = TypeConversion.ToBoolean(leftOperand);
result = Comparison.Compare(OutSet, operation, leftBoolean, value.Value);
if (result != null)
{
break;
}
result = ArithmeticOperation.LeftAbstractArithmetic(flow, operation,
TypeConversion.ToInteger(value.Value));
if (result != null)
{
break;
}
result = LogicalOperation.Logical(OutSet, operation, leftBoolean, value.Value);
if (result != null)
{
break;
}
base.VisitBooleanValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitAssociativeArray(AssociativeArray value)
{
result = Comparison.RightAlwaysGreater(OutSet, operation);
if (result != null)
{
return;
}
result = LogicalOperation.Logical(OutSet, operation, leftOperand,
TypeConversion.ToNativeBoolean(Snapshot, value));
if (result != null)
{
return;
}
result = BitwiseOperation.Bitwise(OutSet, operation);
if (result != null)
{
return;
}
if (ArithmeticOperation.IsArithmetic(operation))
{
// TODO: This must be fatal error
SetWarning("Unsupported operand type: Arithmetic of array and numeric type");
result = OutSet.AnyValue;
return;
}
base.VisitAssociativeArray(value);
}
/// <inheritdoc />
public override void VisitFloatValue(FloatValue value)
{
switch (operation)
{
case Operations.Mod:
result = ModuloOperation.AbstractModulo(flow, value.Value);
break;
default:
result = ArithmeticOperation.LeftAbstractArithmetic(flow, operation, value.Value);
if (result != null)
{
break;
}
result = LogicalOperation.Logical(OutSet, operation,
TypeConversion.ToBoolean(leftOperand), TypeConversion.ToBoolean(value.Value));
if (result != null)
{
break;
}
base.VisitFloatValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitAssociativeArray(AssociativeArray value)
{
switch (operation)
{
case Operations.Identical:
result = OutSet.CreateBool(false);
break;
case Operations.NotIdentical:
result = OutSet.CreateBool(true);
break;
case Operations.Mod:
SetWarning("Object cannot be converted to integer by modulo operation",
AnalysisWarningCause.OBJECT_CONVERTED_TO_INTEGER);
result = ModuloOperation.AbstractModulo(flow);
break;
default:
result = Comparison.LeftAlwaysGreater(OutSet, operation);
if (result != null)
{
break;
}
if (ArithmeticOperation.IsArithmetic(operation))
{
SetWarning("Object cannot be converted to integer by arithmetic operation",
AnalysisWarningCause.OBJECT_CONVERTED_TO_INTEGER);
// TODO: This must be fatal error
SetWarning("Unsupported operand type: Arithmetic of array and object type");
result = OutSet.AnyValue;
break;
}
result = LogicalOperation.Logical(OutSet, operation,
TypeConversion.ToBoolean(leftOperand),
TypeConversion.ToNativeBoolean(Snapshot, value));
if (result != null)
{
break;
}
result = BitwiseOperation.Bitwise(OutSet, operation);
if (result != null)
{
SetWarning("Object cannot be converted to integer by bitwise operation",
AnalysisWarningCause.OBJECT_CONVERTED_TO_INTEGER);
break;
}
base.VisitAssociativeArray(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 VisitIntervalFloatValue(FloatIntervalValue value)
{
result = LogicalOperation.Logical(OutSet, operation, leftOperand, value);
if (result != null)
{
return;
}
base.VisitIntervalFloatValue(value);
}
/// <inheritdoc />
public override void VisitFloatValue(FloatValue value)
{
result = LogicalOperation.Logical(OutSet, operation, leftOperand,
TypeConversion.ToBoolean(value.Value));
if (result != null)
{
return;
}
base.VisitFloatValue(value);
}
/// <inheritdoc />
public override void VisitObjectValue(ObjectValue value)
{
switch (operation)
{
case Operations.Identical:
case Operations.NotIdentical:
// TODO: Compare if two objects are the same instances of the same class
result = OutSet.AnyBooleanValue;
break;
case Operations.Mod:
SetWarning("Both objects cannot be converted to integers by modulo operation",
AnalysisWarningCause.OBJECT_CONVERTED_TO_INTEGER);
result = ModuloOperation.AbstractModulo(flow);
break;
default:
if (Comparison.IsOperationComparison(operation))
{
// TODO: Two object instances are equal if they have the same attributes
// and their values, and are instances of the same class.
result = OutSet.AnyBooleanValue;
break;
}
result = ArithmeticOperation.AbstractIntegerArithmetic(flow, operation);
if (result != null)
{
SetWarning("Both objects cannot be converted to integers by arithmetic operation",
AnalysisWarningCause.OBJECT_CONVERTED_TO_INTEGER);
break;
}
result = LogicalOperation.Logical(OutSet, operation,
TypeConversion.ToBoolean(leftOperand), TypeConversion.ToBoolean(value));
if (result != null)
{
break;
}
result = BitwiseOperation.Bitwise(OutSet, operation);
if (result != null)
{
SetWarning("Both objects cannot be converted to integers by bitwise operation",
AnalysisWarningCause.OBJECT_CONVERTED_TO_INTEGER);
break;
}
base.VisitObjectValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitAnyResourceValue(AnyResourceValue 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);
break;
default:
result = Comparison.LeftAlwaysGreater(OutSet, operation);
if (result != null)
{
break;
}
result = ArithmeticOperation.AbstractIntegerArithmetic(flow, operation);
if (result != null)
{
// Arithmetic objects and resources is nonsence
SetWarning("Object cannot be converted to integer by arithmetic operation",
AnalysisWarningCause.OBJECT_CONVERTED_TO_INTEGER);
break;
}
result = LogicalOperation.Logical(OutSet, operation,
TypeConversion.ToBoolean(leftOperand), TypeConversion.ToBoolean(value));
if (result != null)
{
break;
}
result = BitwiseOperation.Bitwise(OutSet, operation);
if (result != null)
{
// Bitwise operation with resource can give any integer
SetWarning("Object cannot be converted to integer by bitwise operation",
AnalysisWarningCause.OBJECT_CONVERTED_TO_INTEGER);
break;
}
base.VisitAnyResourceValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitAnyObjectValue(AnyObjectValue value)
{
switch (operation)
{
case Operations.Identical:
case Operations.NotIdentical:
// It cannot be decided if they are identical or not.
result = OutSet.AnyBooleanValue;
break;
case Operations.Mod:
SetWarning("Object cannot be converted to integer by modulo operation",
AnalysisWarningCause.OBJECT_CONVERTED_TO_INTEGER);
result = ModuloOperation.AbstractModulo(flow);
break;
default:
result = Comparison.AbstractCompare(OutSet, operation);
if (result != null)
{
break;
}
result = ArithmeticOperation.AbstractIntegerArithmetic(flow, operation);
if (result != null)
{
SetWarning("Both objects cannot be converted to integers by arithmetic operation",
AnalysisWarningCause.OBJECT_CONVERTED_TO_INTEGER);
break;
}
result = LogicalOperation.Logical(OutSet, operation,
TypeConversion.ToBoolean(leftOperand), TypeConversion.ToBoolean(value));
if (result != null)
{
break;
}
result = BitwiseOperation.Bitwise(OutSet, operation);
if (result != null)
{
SetWarning("Both objects cannot be converted to integers by bitwise operation",
AnalysisWarningCause.OBJECT_CONVERTED_TO_INTEGER);
break;
}
base.VisitAnyObjectValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitStringValue(StringValue 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.Value);
break;
default:
if (Comparison.IsOperationComparison(operation))
{
// TODO: The comparison of string with object depends upon whether the object has
// the "__toString" magic method implemented. If so, the string comparison is
// performed. Otherwise, the object is always greater than string.
result = OutSet.AnyBooleanValue;
break;
}
result = LogicalOperation.Logical(OutSet, operation,
TypeConversion.ToBoolean(leftOperand), TypeConversion.ToBoolean(value.Value));
if (result != null)
{
break;
}
int integerValue;
double floatValue;
bool isInteger;
TypeConversion.TryConvertToNumber(value.Value, true, out integerValue,
out floatValue, out isInteger);
result = isInteger
? ArithmeticOperation.LeftAbstractArithmetic(flow, operation, integerValue)
: ArithmeticOperation.LeftAbstractArithmetic(flow, operation, floatValue);
if (result != null)
{
SetWarning("Object cannot be converted to integer by arithmetic operation",
AnalysisWarningCause.OBJECT_CONVERTED_TO_INTEGER);
break;
}
base.VisitStringValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitFloatValue(FloatValue value)
{
switch (operation)
{
case Operations.Identical:
SetWarning("Comparing floating-point numbers directly for equality");
result = OutSet.CreateBool(leftOperand.Value == value.Value);
break;
case Operations.NotIdentical:
SetWarning("Comparing floating-point numbers directly for non-equality");
result = OutSet.CreateBool(leftOperand.Value != value.Value);
break;
case Operations.Mod:
result = ModuloOperation.Modulo(flow, leftOperand.Value, value.Value);
break;
default:
result = Comparison.Compare(OutSet, operation, leftOperand.Value, value.Value);
if (result != null)
{
break;
}
result = ArithmeticOperation.Arithmetic(flow, operation, leftOperand.Value, value.Value);
if (result != null)
{
break;
}
result = BitwiseOperation.Bitwise(OutSet, operation, leftOperand.Value, value.Value);
if (result != null)
{
break;
}
result = LogicalOperation.Logical(OutSet, operation,
TypeConversion.ToBoolean(leftOperand.Value), TypeConversion.ToBoolean(value.Value));
if (result != null)
{
break;
}
base.VisitFloatValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitAssociativeArray(AssociativeArray value)
{
switch (operation)
{
case Operations.Identical:
case Operations.NotIdentical:
// TODO: They must be the same and indices must be in the same order
result = OutSet.AnyBooleanValue;
break;
case Operations.Mod:
result = ModuloOperation.Modulo(flow,
TypeConversion.ToNativeInteger(Snapshot, leftOperand),
TypeConversion.ToNativeInteger(Snapshot, value));
break;
default:
if (Comparison.IsOperationComparison(operation))
{
// TODO: We compare arrays first by the number of elements and second
// if key from left operand is not found in right operand then arrays are
// uncomparable, otherwise we compare value by value
result = OutSet.AnyBooleanValue;
break;
}
result = LogicalOperation.Logical(OutSet, operation,
TypeConversion.ToNativeBoolean(Snapshot, leftOperand),
TypeConversion.ToNativeBoolean(Snapshot, value));
if (result != null)
{
break;
}
result = BitwiseOperation.Bitwise(OutSet, operation,
TypeConversion.ToNativeInteger(Snapshot, leftOperand),
TypeConversion.ToNativeInteger(Snapshot, value));
if (result != null)
{
break;
}
base.VisitAssociativeArray(value);
break;
}
}
/// <inheritdoc />
public override void VisitAnyResourceValue(AnyResourceValue value)
{
switch (operation)
{
case Operations.Identical:
case Operations.NotIdentical:
result = OutSet.AnyBooleanValue;
break;
case Operations.Mod:
result = ModuloOperation.AbstractModulo(flow);
break;
default:
result = Comparison.AbstractCompare(OutSet, operation);
if (result != null)
{
// Comapring of resource and integer makes no sence.
break;
}
result = ArithmeticOperation.AbstractIntegerArithmetic(flow, operation);
if (result != null)
{
// Arithmetic with resources is nonsence
break;
}
result = LogicalOperation.Logical(OutSet, operation,
TypeConversion.ToBoolean(leftOperand), TypeConversion.ToBoolean(value));
if (result != null)
{
break;
}
result = BitwiseOperation.Bitwise(OutSet, operation);
if (result != null)
{
// Bitwise operation with resource can give any integer
break;
}
base.VisitAnyResourceValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitIntegerValue(IntegerValue value)
{
switch (operation)
{
case Operations.Identical:
result = OutSet.CreateBool(leftOperand.Value == value.Value);
break;
case Operations.NotIdentical:
result = OutSet.CreateBool(leftOperand.Value != value.Value);
break;
case Operations.Mod:
result = ModuloOperation.Modulo(flow, leftOperand.Value, value.Value);
break;
default:
result = Comparison.Compare(OutSet, operation, leftOperand.Value, value.Value);
if (result != null)
{
break;
}
result = ArithmeticOperation.Arithmetic(flow, operation, leftOperand.Value, value.Value);
if (result != null)
{
break;
}
result = BitwiseOperation.Bitwise(OutSet, operation, leftOperand.Value, value.Value);
if (result != null)
{
break;
}
result = LogicalOperation.Logical(OutSet, operation,
TypeConversion.ToBoolean(leftOperand.Value), TypeConversion.ToBoolean(value.Value));
if (result != null)
{
break;
}
base.VisitIntegerValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitAnyObjectValue(AnyObjectValue value)
{
switch (operation)
{
case Operations.Identical:
result = OutSet.CreateBool(false);
break;
case Operations.NotIdentical:
result = OutSet.CreateBool(true);
break;
case Operations.Mod:
SetWarning("Object cannot be converted to integer by modulo operation",
AnalysisWarningCause.OBJECT_CONVERTED_TO_INTEGER);
result = ModuloOperation.AbstractModulo(flow);
break;
default:
result = Comparison.RightAlwaysGreater(OutSet, operation);
if (result != null)
{
break;
}
result = LogicalOperation.Logical(OutSet, operation,
TypeConversion.ToNativeBoolean(Snapshot, leftOperand),
TypeConversion.ToBoolean(value));
if (result != null)
{
break;
}
result = BitwiseOperation.Bitwise(OutSet, operation);
if (result != null)
{
SetWarning("Object cannot be converted to integer by bitwise operation",
AnalysisWarningCause.OBJECT_CONVERTED_TO_INTEGER);
break;
}
base.VisitAnyObjectValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitBooleanValue(BooleanValue value)
{
switch (operation)
{
case Operations.Identical:
result = OutSet.CreateBool(leftOperand.Value == value.Value);
break;
case Operations.NotIdentical:
result = OutSet.CreateBool(leftOperand.Value != value.Value);
break;
default:
result = Comparison.Compare(OutSet, operation, leftOperand.Value, value.Value);
if (result != null)
{
break;
}
result = LogicalOperation.Logical(OutSet, operation, leftOperand.Value, value.Value);
if (result != null)
{
break;
}
var leftInteger = TypeConversion.ToInteger(leftOperand.Value);
var rightInteger = TypeConversion.ToInteger(value.Value);
result = ArithmeticOperation.Arithmetic(flow, operation, leftInteger, rightInteger);
if (result != null)
{
break;
}
result = BitwiseOperation.Bitwise(OutSet, operation, leftInteger, rightInteger);
if (result != null)
{
break;
}
base.VisitBooleanValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitAnyResourceValue(AnyResourceValue 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);
break;
default:
result = Comparison.AbstractCompare(OutSet, operation);
if (result != null)
{
// Comapring of resource and number makes no sence.
break;
}
result = LogicalOperation.Logical(OutSet, operation, leftOperand,
TypeConversion.ToBoolean(value));
if (result != null)
{
break;
}
result = BitwiseOperation.Bitwise(OutSet, operation);
if (result != null)
{
// Bitwise operation with resource can give any integer
break;
}
base.VisitAnyResourceValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitAnyResourceValue(AnyResourceValue 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);
break;
default:
result = Comparison.LeftAlwaysGreater(OutSet, operation);
if (result != null)
{
break;
}
result = LogicalOperation.Logical(OutSet, operation,
TypeConversion.ToNativeBoolean(Snapshot, leftOperand),
TypeConversion.ToBoolean(value));
if (result != null)
{
break;
}
result = BitwiseOperation.Bitwise(OutSet, operation);
if (result != null)
{
// Bitwise operation with resource can give any integer
break;
}
base.VisitAnyResourceValue(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, value);
break;
default:
var floatInterval = TypeConversion.ToFloatInterval(OutSet, value);
result = Comparison.IntervalCompare(OutSet, operation, leftOperand.Value, floatInterval);
if (result != null)
{
break;
}
result = ArithmeticOperation.Arithmetic(flow, operation,
leftOperand.Value, floatInterval);
if (result != null)
{
break;
}
result = LogicalOperation.Logical(OutSet, operation,
TypeConversion.ToBoolean(leftOperand.Value), value);
if (result != null)
{
break;
}
base.VisitIntervalIntegerValue(value);
break;
}
}