@Override public boolean equals(Object o) { if (o instanceof DeclaredTypeOperator) { DeclaredTypeOperator d = (DeclaredTypeOperator) o; return type.equals(d.type); } else { return false; } } }
@Override public boolean equals(Object o) { if (o instanceof DeclaredTypeOperator) { DeclaredTypeOperator d = (DeclaredTypeOperator) o; return type.equals(d.type); } else { return false; } } }
@Override public boolean equals(Object obj) { if (obj == null) { return false; } if (getClass().equals(obj.getClass())) { JavaTypeContext other = (JavaTypeContext) obj; return type.equals(other.type); } else { return false; } }
@Override public boolean equals(Object obj) { if (obj == null) { return false; } if (getClass().equals(obj.getClass())) { JavaTypeContext other = (JavaTypeContext) obj; return type.equals(other.type); } else { return false; } }
/** * Note that we need evaluate this operator at most once */ @Override public byte evaluate(TypeVariable lhs) { if (lhs.type.equals(type)) { return NOT_CHANGED_AND_FIXED; } else { lhs.setType(type); return CHANGED_AND_FIXED; } }
@Override public boolean equals(Object obj) { if (obj == null) { return false; } if (getClass().equals(obj.getClass())) { GetMethodContext other = (GetMethodContext) obj; return type.equals(other.type) && name.equals(other.name); } else { return false; } }
@Override public boolean equals(Object obj) { if (obj == null) { return false; } if (getClass().equals(obj.getClass())) { GetMethodContext other = (GetMethodContext) obj; return type.equals(other.type) && name.equals(other.name); } else { return false; } }
/** * Note that we need evaluate this operator at most once */ @Override public byte evaluate(TypeVariable lhs) { if (lhs.type.equals(type)) { return NOT_CHANGED_AND_FIXED; } else { lhs.setType(type); return CHANGED_AND_FIXED; } }
/** * TODO: work on efficiency shortcuts for this. */ @Override public byte evaluate(TypeVariable lhs, TypeVariable[] rhsOperands) { TypeAbstraction lhsType = lhs.getType(); TypeVariable rhs = rhsOperands[0]; TypeAbstraction rhsType = rhs.getType(); if (lhsType.equals(rhsType)) { return NOT_CHANGED; } else { lhs.setType(rhsType); return CHANGED; } }
/** * TODO: work on efficiency shortcuts for this. */ @Override public byte evaluate(TypeVariable lhs, TypeVariable[] rhsOperands) { TypeAbstraction lhsType = lhs.getType(); TypeVariable rhs = rhsOperands[0]; TypeAbstraction rhsType = rhs.getType(); if (lhsType.equals(rhsType)) { return NOT_CHANGED; } else { lhs.setType(rhsType); return CHANGED; } }
@Override public byte evaluate(TypeVariable lhs, TypeVariable[] rhs) { TypeAbstraction lhsType = lhs.getType(); TypeAbstraction meet = TypeAbstraction.TOP; for (TypeVariable r : rhs) { if (r != null && r.getType() != null) { meet = meet.meet(r.getType()); } } if (lhsType.equals(meet)) { return NOT_CHANGED; } else { lhs.setType(meet); return CHANGED; } }
@Override public byte evaluate(TypeVariable lhs, TypeVariable[] rhs) { TypeAbstraction lhsType = lhs.getType(); TypeAbstraction meet = TypeAbstraction.TOP; for (TypeVariable r : rhs) { if (r != null && r.getType() != null) { meet = meet.meet(r.getType()); } } if (lhsType.equals(meet)) { return NOT_CHANGED; } else { lhs.setType(meet); return CHANGED; } }
if (lhsType.equals(meet)) { return NOT_CHANGED; } else {
if (lhsType.equals(meet)) { return NOT_CHANGED; } else {
TypeAbstraction lhsType = L.getType(); if (lhsType.equals(meet)) { return NOT_CHANGED; } else {
@Override public byte evaluate(TypeVariable _lhs, TypeVariable[] _rhs) { /** * TODO: Find a better solution than downcasting. Downcasting is * really ugly, although I can be sure here that it succeeds because * I control what type the parameters have. There must be a cleaner * solution which does not cause tons of changes in WALA's code, but * I don't see it yet... */ assert _lhs instanceof DalvikTypeVariable; assert _rhs instanceof DalvikTypeVariable[]; DalvikTypeVariable lhs = (DalvikTypeVariable) _lhs; DalvikTypeVariable[] rhs = (DalvikTypeVariable[]) _rhs; TypeAbstraction lhsType = lhs.getType(); TypeAbstraction meet = TypeAbstraction.TOP; boolean ignoreZero = containsNonPrimitiveAndZero(rhs); for (int i = 0; i < rhs.length; i++) { if (rhs[i] != null && rhs[i].getType() != null && !(ignoreZero && rhs[i].isIntZeroConstant())) { TypeVariable r = rhs[i]; meet = meet.meet(r.getType()); } } if (lhsType.equals(meet)) { return NOT_CHANGED; } else { lhs.setType(meet); return CHANGED; } }
TypeAbstraction lhsType = L.getType(); if (lhsType.equals(meet)) { return NOT_CHANGED; } else {
@Override public byte evaluate(TypeVariable _lhs, TypeVariable[] _rhs) { /** * TODO: Find a better solution than downcasting. Downcasting is * really ugly, although I can be sure here that it succeeds because * I control what type the parameters have. There must be a cleaner * solution which does not cause tons of changes in WALA's code, but * I don't see it yet... */ assert _lhs instanceof DalvikTypeVariable; assert _rhs instanceof DalvikTypeVariable[]; DalvikTypeVariable lhs = (DalvikTypeVariable) _lhs; DalvikTypeVariable[] rhs = (DalvikTypeVariable[]) _rhs; TypeAbstraction lhsType = lhs.getType(); TypeAbstraction meet = TypeAbstraction.TOP; boolean ignoreZero = containsNonPrimitiveAndZero(rhs); for (int i = 0; i < rhs.length; i++) { if (rhs[i] != null && rhs[i].getType() != null && !(ignoreZero && rhs[i].isIntZeroConstant())) { TypeVariable r = rhs[i]; meet = meet.meet(r.getType()); } } if (lhsType.equals(meet)) { return NOT_CHANGED; } else { lhs.setType(meet); return CHANGED; } }
@Override public byte evaluate(TypeVariable lhs, TypeVariable[] rhs) { TypeAbstraction arrayType = getType(load.getArrayRef()); if (arrayType == null || arrayType.equals(TypeAbstraction.TOP)) { return NOT_CHANGED;
@Override public byte evaluate(TypeVariable lhs, TypeVariable[] rhs) { TypeAbstraction arrayType = getType(load.getArrayRef()); if (arrayType == null || arrayType.equals(TypeAbstraction.TOP)) { return NOT_CHANGED;