/// <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 = Comparison.AbstractCompare(OutSet, operation);
if (result != null)
{
// Ommitted warning message that object cannot be converted to integer
break;
}
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 = LogicalOperation.AbstractLogical(OutSet, operation,
TypeConversion.ToBoolean(leftOperand));
if (result != null)
{
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 VisitAnyScalarValue(AnyScalarValue value)
{
result = Comparison.AbstractCompare(OutSet, operation);
if (result != null)
{
return;
}
result = BitwiseOperation.Bitwise(OutSet, operation);
if (result != null)
{
return;
}
base.VisitAnyScalarValue(value);
}
/// <inheritdoc />
public override void VisitAnyScalarValue(AnyScalarValue value)
{
result = LogicalOperation.AbstractLogical(OutSet, operation, leftOperand);
if (result != null)
{
return;
}
result = BitwiseOperation.Bitwise(OutSet, operation);
if (result != null)
{
return;
}
base.VisitAnyScalarValue(value);
}
/// <inheritdoc />
public override void VisitGenericIntervalValue <T>(IntervalValue <T> value)
{
result = LogicalOperation.AbstractLogical(OutSet, operation, value);
if (result != null)
{
return;
}
result = BitwiseOperation.Bitwise(OutSet, operation);
if (result != null)
{
// It is too complicated to represend result of bitwise operation with interval
return;
}
base.VisitGenericIntervalValue(value);
}
/// <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 VisitAnyBooleanValue(AnyBooleanValue value)
{
switch (operation)
{
case Operations.Identical:
result = OutSet.CreateBool(false);
break;
case Operations.NotIdentical:
result = OutSet.CreateBool(true);
break;
default:
result = Comparison.RightAbstractBooleanCompare(OutSet, operation,
TypeConversion.ToBoolean(leftOperand.Value));
if (result != null)
{
break;
}
result = BitwiseOperation.Bitwise(OutSet, operation);
if (result != null)
{
break;
}
int integerValue;
double floatValue;
bool isInteger;
TypeConversion.TryConvertToNumber(leftOperand.Value, true,
out integerValue, out floatValue, out isInteger);
result = isInteger
? ArithmeticOperation.RightAbstractBooleanArithmetic(flow, operation, integerValue)
: ArithmeticOperation.RightAbstractBooleanArithmetic(flow, operation, floatValue);
if (result != null)
{
break;
}
base.VisitAnyBooleanValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitAssociativeArray(AssociativeArray value)
{
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 scalar type");
result = OutSet.AnyValue;
return;
}
base.VisitAssociativeArray(value);
}
/// <inheritdoc />
public override void VisitScalarValue(ScalarValue value)
{
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
return;
}
result = BitwiseOperation.Bitwise(OutSet, operation);
if (result != null)
{
// Ommitted warning message that object cannot be converted to integer
return;
}
base.VisitScalarValue(value);
}
/// <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 VisitAnyObjectValue(AnyObjectValue value)
{
switch (operation)
{
case Operations.Mod:
// Ommitted warning message that object cannot be converted to integer
SetWarning("Object cannot be converted to integer by modulo operation",
AnalysisWarningCause.OBJECT_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
SetWarning("Object cannot be converted to integer by arithmetic operation",
AnalysisWarningCause.OBJECT_CONVERTED_TO_INTEGER);
break;
}
result = LogicalOperation.AbstractLogical(OutSet, operation,
TypeConversion.ToBoolean(value));
if (result != null)
{
break;
}
result = BitwiseOperation.Bitwise(OutSet, operation);
if (result != null)
{
// Ommitted warning message that object cannot be converted to integer
SetWarning("Object cannot be converted to integer by bitwise operation",
AnalysisWarningCause.OBJECT_CONVERTED_TO_INTEGER);
break;
}
base.VisitAnyObjectValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitAnyValue(AnyValue value)
{
switch (operation)
{
case Operations.Mod:
// Ommitted warning messages that objects cannot be converted to integers
result = ModuloOperation.AbstractModulo(flow);
break;
default:
result = Comparison.AbstractCompare(OutSet, operation);
if (result != null)
{
// Ommitted warning message that object cannot be converted to integer
break;
}
result = ArithmeticOperation.AbstractFloatArithmetic(Snapshot, operation);
if (result != null)
{
// Ommitted warning messages that objects cannot be converted to integers
// Ommitted error reports that arrays are unsupported operands in arithmetic operation
break;
}
result = LogicalOperation.AbstractLogical(OutSet, operation);
if (result != null)
{
break;
}
result = BitwiseOperation.Bitwise(OutSet, operation);
if (result != null)
{
// Ommitted warning messages that objects cannot be converted to integers
break;
}
base.VisitAnyValue(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 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 VisitGenericIntervalValue <T>(IntervalValue <T> value)
{
switch (operation)
{
case Operations.Identical:
case Operations.NotIdentical:
result = OutSet.AnyBooleanValue;
break;
default:
result = Comparison.AbstractCompare(OutSet, operation);
if (result != null)
{
// Ommitted warning message that object cannot be converted to integer
break;
}
result = ArithmeticOperation.AbstractFloatArithmetic(Snapshot, operation);
if (result != null)
{
// Ommitted error report that array is unsupported operand in arithmetic operation
break;
}
result = LogicalOperation.AbstractLogical(OutSet, operation, value);
if (result != null)
{
break;
}
result = BitwiseOperation.Bitwise(OutSet, operation);
if (result != null)
{
// Ommitted warning message that object cannot be converted to integer
break;
}
base.VisitGenericIntervalValue(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.Modulo(flow,
TypeConversion.ToInteger(leftOperand.Value), value.Value);
break;
default:
var rightBoolean = TypeConversion.ToBoolean(value.Value);
result = Comparison.Compare(OutSet, operation, leftOperand.Value, rightBoolean);
if (result != null)
{
break;
}
var leftInteger = TypeConversion.ToInteger(leftOperand.Value);
result = ArithmeticOperation.Arithmetic(flow, operation, leftInteger, value.Value);
if (result != null)
{
break;
}
result = LogicalOperation.Logical(OutSet, operation, leftOperand.Value, rightBoolean);
if (result != null)
{
break;
}
result = BitwiseOperation.Bitwise(OutSet, operation, leftInteger, value.Value);
if (result != null)
{
break;
}
base.VisitFloatValue(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 = Comparison.AbstractCompare(OutSet, operation);
if (result != null)
{
// Ommitted warning message that object cannot be converted to integer
break;
}
result = LogicalOperation.AbstractLogical(OutSet, operation);
if (result != null)
{
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 VisitAnyArrayValue(AnyArrayValue value)
{
switch (operation)
{
case Operations.Mod:
result = ModuloOperation.AbstractModulo(flow);
break;
default:
result = Comparison.RightAlwaysGreater(OutSet, operation);
if (result != null)
{
break;
}
result = LogicalOperation.AbstractLogical(OutSet, operation, leftOperand);
if (result != null)
{
break;
}
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 numeric type");
result = OutSet.AnyValue;
break;
}
base.VisitAnyArrayValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitAnyObjectValue(AnyObjectValue 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:
result = Comparison.AbstractCompare(OutSet, operation);
if (result != null)
{
SetWarning("Object cannot be converted to integer by comparison",
AnalysisWarningCause.OBJECT_CONVERTED_TO_INTEGER);
break;
}
result = LogicalOperation.Logical(OutSet, operation, 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 VisitAssociativeArray(AssociativeArray value)
{
switch (operation)
{
case Operations.Identical:
case Operations.NotIdentical:
result = OutSet.AnyBooleanValue;
break;
case Operations.Mod:
result = ModuloOperation.AbstractModulo(flow,
TypeConversion.ToNativeInteger(Snapshot, value));
break;
default:
result = Comparison.AbstractCompare(OutSet, operation);
if (result != null)
{
break;
}
result = LogicalOperation.AbstractLogical(OutSet, operation,
TypeConversion.ToNativeBoolean(Snapshot, value));
if (result != null)
{
break;
}
result = BitwiseOperation.Bitwise(OutSet, operation);
if (result != null)
{
break;
}
base.VisitAssociativeArray(value);
break;
}
}
/// <inheritdoc />
public override void VisitAnyObjectValue(AnyObjectValue 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:
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 VisitAnyNumericValue(AnyNumericValue value)
{
switch (operation)
{
case Operations.Identical:
result = OutSet.CreateBool(false);
break;
case Operations.NotIdentical:
result = OutSet.CreateBool(true);
break;
default:
result = BitwiseOperation.Bitwise(OutSet, operation);
if (result != null)
{
break;
}
base.VisitAnyNumericValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitAssociativeArray(AssociativeArray value)
{
switch (operation)
{
case Operations.Mod:
// Ommitted warnings messages that objects cannot be converted to integers
result = ModuloOperation.AbstractModulo(flow,
TypeConversion.ToNativeInteger(Snapshot, value));
break;
default:
result = LogicalOperation.AbstractLogical(OutSet, operation);
if (result != null)
{
break;
}
result = BitwiseOperation.Bitwise(OutSet, operation);
if (result != null)
{
// Ommitted warnings messages that objects cannot be converted to integers
break;
}
if (ArithmeticOperation.IsArithmetic(operation))
{
// Ommitted warning message that object cannot be converted to integer
// TODO: This must be fatal error
SetWarning("Unsupported operand type: Arithmetic of array and other value");
result = OutSet.AnyValue;
break;
}
base.VisitAssociativeArray(value);
break;
}
}
/// <inheritdoc />
public override void VisitGenericIntervalValue <T>(IntervalValue <T> value)
{
switch (operation)
{
case Operations.Identical:
result = OutSet.CreateBool(false);
break;
case Operations.NotIdentical:
result = OutSet.CreateBool(true);
break;
default:
result = Comparison.AbstractCompare(OutSet, operation);
if (result != null)
{
break;
}
result = LogicalOperation.Logical(OutSet, operation,
TypeConversion.ToBoolean(leftOperand), value);
if (result != null)
{
break;
}
result = BitwiseOperation.Bitwise(OutSet, operation);
if (result != null)
{
// It is too complicated to represend result of bitwise operation with interval
break;
}
base.VisitGenericIntervalValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitAnyArrayValue(AnyArrayValue 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)
{
break;
}
result = LogicalOperation.AbstractLogical(OutSet, operation);
if (result != null)
{
break;
}
result = BitwiseOperation.Bitwise(OutSet, operation);
if (result != null)
{
break;
}
base.VisitAnyArrayValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitGenericIntervalValue <T>(IntervalValue <T> value)
{
switch (operation)
{
case Operations.Identical:
result = OutSet.CreateBool(false);
break;
case Operations.NotIdentical:
result = OutSet.CreateBool(true);
break;
default:
result = Comparison.AbstractCompare(OutSet, operation);
if (result != null)
{
// Probably since PHP version 5.1.5, Object converts into a number when comparing
// with other number. However, since this conversion is undefined, we are comparing
// concrete number with abstract number that can result into both true and false
SetWarning("Object cannot be converted to number by comparison",
AnalysisWarningCause.OBJECT_CONVERTED_TO_INTEGER);
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.VisitGenericIntervalValue(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;
default:
result = Comparison.LeftAbstractBooleanCompare(OutSet, operation, value.Value);
if (result != null)
{
break;
}
result = LogicalOperation.AbstractLogical(OutSet, operation, value.Value);
if (result != null)
{
break;
}
// If the left operand can not be recognized, result can be any integer value.
result = BitwiseOperation.Bitwise(OutSet, operation);
if (result != null)
{
break;
}
base.VisitBooleanValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitAnyArrayValue(AnyArrayValue value)
{
switch (operation)
{
case Operations.Mod:
// Ommitted warning message that object cannot be converted to integer
result = ModuloOperation.AbstractModulo(flow);
break;
default:
result = LogicalOperation.AbstractLogical(OutSet, operation);
if (result != null)
{
break;
}
result = BitwiseOperation.Bitwise(OutSet, operation);
if (result != null)
{
// Ommitted warning message that object cannot be converted to integer
break;
}
if (ArithmeticOperation.IsArithmetic(operation))
{
// Ommitted warning message that object cannot be converted to integer
// TODO: This must be fatal error
SetWarning("Unsupported operand type: Arithmetic of array and other type");
result = OutSet.AnyValue;
break;
}
base.VisitAnyArrayValue(value);
break;
}
}
