/// <inheritdoc />
public override void VisitAnyObjectValue(AnyObjectValue value)
{
if (Comparison.IsOperationComparison(operation))
{
// 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. Since we cannot
// determine whether the abstract object has or has not the method,
// we must return indeterminate boolean value.
result = OutSet.AnyBooleanValue;
return;
}
result = LogicalOperation.AbstractLogical(OutSet, operation, TypeConversion.ToBoolean(value));
if (result != null)
{
return;
}
result = ArithmeticOperation.AbstractFloatArithmetic(Snapshot, operation);
if (result != null)
{
SetWarning("Object cannot be converted to integer by arithmetic operation",
AnalysisWarningCause.OBJECT_CONVERTED_TO_INTEGER);
return;
}
base.VisitAnyObjectValue(value);
}
/// <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 />
protected override Value cloneValue()
{
AnyObjectValue value = new AnyObjectValue();
value.setStorage(getStorage());
return(value);
}
/// <inheritdoc />
public override void VisitAnyObjectValue(AnyObjectValue value)
{
switch (operation)
{
case Operations.Plus:
SetWarning("Object cannot be converted to integer by unary plus operation",
AnalysisWarningCause.OBJECT_CONVERTED_TO_INTEGER);
result = OutSet.AnyIntegerValue;
break;
case Operations.Minus:
SetWarning("Object cannot be converted to integer by unary minus operation",
AnalysisWarningCause.OBJECT_CONVERTED_TO_INTEGER);
result = OutSet.AnyIntegerValue;
break;
case Operations.LogicNegation:
result = OutSet.CreateBool(!TypeConversion.ToBoolean(value));
break;
case Operations.Int32Cast:
SetWarning("Object cannot be converted to integer",
AnalysisWarningCause.OBJECT_CONVERTED_TO_INTEGER);
result = OutSet.AnyIntegerValue;
break;
case Operations.FloatCast:
case Operations.DoubleCast:
SetWarning("Object cannot be converted to float",
AnalysisWarningCause.OBJECT_CONVERTED_TO_INTEGER);
result = OutSet.AnyFloatValue;
break;
case Operations.Print:
// The operator convert value to string and print it. The string value is not used
// to resolve the entire expression. Instead, the false value is returned.
// TODO: This is a quest for tainted analysis
result = OutSet.CreateBool(false);
// TODO: Object can be converted only if it has __toString magic method implemented
break;
case Operations.Clone:
// TODO: Object can be converted only if it has __clone magic method implemented
result = OutSet.AnyObjectValue;
break;
case Operations.ObjectCast:
result = value;
break;
case Operations.ArrayCast:
result = OutSet.AnyArrayValue;
break;
default:
base.VisitAnyObjectValue(value);
break;
}
}
/// <inheritdoc />
public override void VisitAnyObjectValue(AnyObjectValue value)
{
result = Comparison.AbstractCompare(OutSet, operation);
if (result != null)
{
SetWarning("Object cannot be converted to integer by comparison",
AnalysisWarningCause.OBJECT_CONVERTED_TO_INTEGER);
return;
}
base.VisitAnyObjectValue(value);
}
/// <inheritdoc />
public override void VisitAnyObjectValue(AnyObjectValue value)
{
result = ArithmeticOperation.RightAbstractArithmetic(flow, operation, leftOperand);
if (result != null)
{
SetWarning("Object cannot be converted to integer by arithmetic operation",
AnalysisWarningCause.OBJECT_CONVERTED_TO_INTEGER);
return;
}
base.VisitAnyObjectValue(value);
}
/// <inheritdoc />
public override void VisitAnyObjectValue(AnyObjectValue value)
{
// An object is always greater then null value
switch (operation)
{
case Operations.Equal:
case Operations.GreaterThanOrEqual:
result = OutSet.CreateBool(false);
break;
case Operations.NotEqual:
case Operations.LessThan:
case Operations.Or:
case Operations.Xor:
result = OutSet.CreateBool(true);
break;
case Operations.Mul:
case Operations.BitAnd:
case Operations.ShiftLeft:
case Operations.ShiftRight:
SetWarning("Object cannot be converted to integer",
AnalysisWarningCause.OBJECT_CONVERTED_TO_INTEGER);
result = OutSet.CreateInt(0);
break;
case Operations.Add:
case Operations.Sub:
case Operations.BitOr:
case Operations.BitXor:
SetWarning("Object cannot be converted to integer",
AnalysisWarningCause.OBJECT_CONVERTED_TO_INTEGER);
result = OutSet.AnyIntegerValue;
break;
case Operations.Div:
case Operations.Mod:
SetWarning("Object cannot be converted to integer",
AnalysisWarningCause.OBJECT_CONVERTED_TO_INTEGER);
// We can assume that object is not zero, because null is zero
result = OutSet.CreateInt(0);
break;
default:
base.VisitAnyObjectValue(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 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 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 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;
}
}
public override void VisitAnyObjectValue(AnyObjectValue value)
{
ContainsAnyValue = true;
locations.Add(new ObjectAnyValueLocation(containingIndex, index, value));
}
/// <inheritdoc />
public override void VisitAnyObjectValue(AnyObjectValue value)
{
Result = StaticObjectVisitorResult.MULTIPLE_RESULTS;
}
/// <inheritdoc />
public override void VisitAnyObjectValue(AnyObjectValue value)
{
// TODO: Object can be converted only if it has __toString magic method implemented
result = null;
abstractResult = OutSet.AnyStringValue;
}
/// <inheritdoc />
public override void VisitAnyObjectValue(AnyObjectValue value)
{
objectVisitor.SetLeftOperand(value);
visitor = objectVisitor;
}
/// <inheritdoc />
public override void VisitAnyObjectValue(AnyObjectValue value)
{
result = TypeConversion.ToBoolean(snapshot, value);
}
public override void VisitAnyObjectValue(AnyObjectValue value)
{
this.AddLocation(new ObjectAnyValueLocation(null, index, value));
}