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