/// <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 VisitIntervalFloatValue(FloatIntervalValue 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:
var floatInterval = TypeConversion.ToFloatInterval(OutSet, leftOperand);
result = Comparison.IntervalCompare(OutSet, operation, floatInterval, value);
if (result != null)
{
break;
}
result = ArithmeticOperation.Arithmetic(flow, operation, leftOperand, value);
if (result != null)
{
break;
}
base.VisitIntervalFloatValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitStringValue(StringValue 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.Value);
break;
default:
result = LogicalOperation.AbstractLogical(OutSet, operation,
TypeConversion.ToBoolean(value.Value));
if (result != null)
{
break;
}
base.VisitStringValue(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 = BitwiseOperation.Bitwise(OutSet, operation);
if (result != null)
{
// Bitwise operation with resource can give any integer
break;
}
base.VisitAnyResourceValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitBooleanValue(BooleanValue value)
{
switch (operation)
{
case Operations.Mod:
// Ommitted warning message that object cannot be converted to integer
result = ModuloOperation.ModuloByBooleanValue(flow, value.Value);
break;
default:
result = Comparison.LeftAbstractBooleanCompare(OutSet, operation, value.Value);
if (result != null)
{
break;
}
result = LogicalOperation.AbstractLogical(OutSet, operation, value.Value);
if (result != null)
{
break;
}
base.VisitBooleanValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitStringValue(StringValue value)
{
switch (operation)
{
case Operations.Mod:
result = ModuloOperation.AbstractModulo(flow, value.Value);
break;
default:
result = Comparison.LeftAlwaysGreater(OutSet, operation);
if (result != null)
{
break;
}
result = LogicalOperation.AbstractLogical(OutSet, operation,
TypeConversion.ToBoolean(value.Value));
if (result != null)
{
break;
}
base.VisitStringValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitAnyValue(AnyValue value)
{
switch (operation)
{
case Operations.Identical:
case Operations.NotIdentical:
result = OutSet.AnyBooleanValue;
break;
case Operations.Mod:
// Ommitted warning message that object cannot be converted to integer
result = ModuloOperation.AbstractModulo(flow);
break;
default:
result = ArithmeticOperation.AbstractFloatArithmetic(Snapshot, operation);
if (result != null)
{
// Ommitted warning message that object cannot be converted to integer
// Ommitted error report that array is unsupported operand in arithmetic operation
break;
}
result = BitwiseOperation.Bitwise(OutSet, operation);
if (result != null)
{
// Ommitted warning message that object cannot be converted to integer
break;
}
base.VisitAnyValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitAnyBooleanValue(AnyBooleanValue value)
{
switch (operation)
{
case Operations.Identical:
result = OutSet.CreateBool(false);
break;
case Operations.NotIdentical:
result = OutSet.CreateBool(true);
break;
case Operations.Mod:
result = ModuloOperation.ModuloByAnyBooleanValue(flow);
break;
default:
result = Comparison.RightAbstractBooleanCompare(OutSet, operation, leftOperand);
if (result != null)
{
break;
}
base.VisitAnyBooleanValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitAnyStringValue(AnyStringValue 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)
{
break;
}
result = ArithmeticOperation.AbstractFloatArithmetic(Snapshot, operation);
if (result != null)
{
// A string can be converted into floating point number too.
break;
}
base.VisitAnyStringValue(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 VisitStringValue(StringValue value)
{
switch (operation)
{
case Operations.Mod:
result = ModuloOperation.Modulo(flow, leftOperand, value.Value);
break;
default:
int integerValue;
double floatValue;
bool isInteger;
TypeConversion.TryConvertToNumber(value.Value, true,
out integerValue, out floatValue, out isInteger);
result = Comparison.IntervalCompare(OutSet, operation, leftOperand, floatValue);
if (result != null)
{
break;
}
result = ArithmeticOperation.Arithmetic(flow, operation, leftOperand, floatValue);
if (result != null)
{
break;
}
base.VisitStringValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitIntervalFloatValue(FloatIntervalValue 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.VisitIntervalFloatValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitFloatValue(FloatValue value)
{
switch (operation)
{
case Operations.Mod:
// When dividend is true and divisor != +-1, result is 1, otherwise 0
result = ModuloOperation.LeftAbstractBooleanModulo(flow, value.Value);
break;
default:
var rightBoolean = TypeConversion.ToBoolean(value.Value);
result = Comparison.LeftAbstractBooleanCompare(OutSet, operation, rightBoolean);
if (result != null)
{
break;
}
result = ArithmeticOperation.LeftAbstractBooleanArithmetic(flow, operation, value.Value);
if (result != null)
{
break;
}
result = LogicalOperation.AbstractLogical(OutSet, operation, rightBoolean);
if (result != null)
{
break;
}
base.VisitFloatValue(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.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 VisitAnyStringValue(AnyStringValue value)
{
switch (operation)
{
case Operations.Equal:
case Operations.NotEqual:
case Operations.GreaterThanOrEqual:
case Operations.LessThan:
case Operations.Or:
case Operations.Xor:
result = OutSet.AnyBooleanValue;
break;
case Operations.Mod:
result = ModuloOperation.AbstractModulo(flow);
break;
case Operations.BitOr:
case Operations.BitXor:
result = OutSet.AnyIntegerValue;
break;
default:
result = ArithmeticOperation.AbstractFloatArithmetic(Snapshot, operation);
if (result != null)
{
break;
}
base.VisitAnyStringValue(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 VisitBooleanValue(BooleanValue value)
{
switch (operation)
{
case Operations.Mod:
result = ModuloOperation.ModuloByBooleanValue(flow, value.Value);
break;
default:
result = Comparison.LeftAbstractBooleanCompare(OutSet, operation, value.Value);
if (result != null)
{
break;
}
result = LogicalOperation.AbstractLogical(OutSet, operation, value.Value);
if (result != null)
{
break;
}
base.VisitBooleanValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitIntervalFloatValue(FloatIntervalValue 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:
result = ArithmeticOperation.LeftAbstractArithmetic(flow, operation, value);
if (result != null)
{
break;
}
base.VisitIntervalFloatValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitUndefinedValue(UndefinedValue value)
{
switch (operation)
{
case Operations.Identical:
case Operations.And:
result = OutSet.CreateBool(false);
break;
case Operations.NotIdentical:
result = OutSet.CreateBool(true);
break;
case Operations.BitAnd:
result = OutSet.CreateInt(0);
break;
case Operations.Div:
result = ArithmeticOperation.DivisionByNull(flow);
break;
case Operations.Mod:
result = ModuloOperation.ModuloByNull(flow);
break;
default:
base.VisitUndefinedValue(value);
break;
}
}
/// <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 VisitAnyArrayValue(AnyArrayValue value)
{
switch (operation)
{
case Operations.Mod:
result = ModuloOperation.AbstractModulo(flow);
break;
default:
result = BitwiseOperation.Bitwise(OutSet, operation);
if (result != null)
{
break;
}
if (ArithmeticOperation.IsArithmetic(operation))
{
// TODO: This must be fatal error
SetWarning("Unsupported operand type: Arithmetic of array and scalar type");
result = OutSet.AnyValue;
break;
}
base.VisitAnyArrayValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitAnyBooleanValue(AnyBooleanValue value)
{
switch (operation)
{
case Operations.Mod:
SetWarning("Object cannot be converted to integer by modulo operation",
AnalysisWarningCause.OBJECT_CONVERTED_TO_INTEGER);
result = ModuloOperation.ModuloByAnyBooleanValue(flow);
break;
default:
result = Comparison.RightAbstractBooleanCompare(OutSet, operation,
TypeConversion.ToBoolean(leftOperand));
if (result != null)
{
break;
}
result = ArithmeticOperation.RightAbstractBooleanArithmetic(flow, operation);
if (result != null)
{
SetWarning("Object cannot be converted to integer by arithmetic operation",
AnalysisWarningCause.OBJECT_CONVERTED_TO_INTEGER);
break;
}
base.VisitAnyBooleanValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitStringValue(StringValue value)
{
switch (operation)
{
case Operations.Mod:
// Ommitted warning message that object cannot be converted to integer
result = ModuloOperation.AbstractModulo(flow, value.Value);
break;
default:
result = Comparison.AbstractCompare(OutSet, operation);
if (result != null)
{
// Ommitted warning message that object cannot be converted to integer
break;
}
result = LogicalOperation.AbstractLogical(OutSet, operation,
TypeConversion.ToBoolean(value.Value));
if (result != null)
{
break;
}
base.VisitStringValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitAnyStringValue(AnyStringValue 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);
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 = ArithmeticOperation.AbstractFloatArithmetic(Snapshot, operation);
if (result != null)
{
// A string can be converted into floating point number too.
break;
}
base.VisitAnyStringValue(value);
break;
}
}
/// <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 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 VisitIntegerValue(IntegerValue value)
{
switch (operation)
{
case Operations.Identical:
result = Comparison.Equal(OutSet, leftOperand, value.Value);
break;
case Operations.NotIdentical:
result = Comparison.NotEqual(OutSet, leftOperand, value.Value);
break;
case Operations.Mod:
result = ModuloOperation.Modulo(flow, leftOperand, value.Value);
break;
default:
result = Comparison.IntervalCompare(OutSet, operation, leftOperand, value.Value);
if (result != null)
{
break;
}
result = ArithmeticOperation.Arithmetic(flow, operation, leftOperand, value.Value);
if (result != null)
{
break;
}
base.VisitIntegerValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitIntervalFloatValue(FloatIntervalValue value)
{
// When comparing, both operands are converted to boolean
switch (operation)
{
case Operations.BitOr:
case Operations.BitXor:
IntervalValue <int> integerInterval;
if (TypeConversion.TryConvertToIntegerInterval(OutSet, value, out integerInterval))
{
result = integerInterval;
}
else
{
result = OutSet.AnyIntegerValue;
}
break;
case Operations.Mod:
result = ModuloOperation.Modulo(flow, TypeConversion.ToInteger(leftOperand), value);
break;
default:
result = ArithmeticOperation.Arithmetic(flow, operation,
TypeConversion.ToFloat(leftOperand), value);
if (result != null)
{
break;
}
base.VisitIntervalFloatValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitAssociativeArray(AssociativeArray value)
{
switch (operation)
{
case Operations.Mod:
result = ModuloOperation.AbstractModulo(flow,
TypeConversion.ToNativeInteger(Snapshot, value));
break;
default:
result = Comparison.RightAlwaysGreater(OutSet, operation);
if (result != null)
{
break;
}
result = LogicalOperation.AbstractLogical(OutSet, operation,
TypeConversion.ToNativeBoolean(Snapshot, value));
if (result != null)
{
break;
}
base.VisitAssociativeArray(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;
}
}
