public void invalidateId(int id) { invalidIds.set(id); } }
private boolean fastAdd(Node n) { boolean ret = bits.set(n.getNumber()); if (ret) { empty = false; } return ret; }
public boolean set(int bit) { acquire(); return value.set(bit); }
/** Adds the given node to the list of descendants of this node and its ancestors. **/ private void fixDescendants(int id) { if (descendants.get(id)) { return; } for (Iterator<TypeNode> parentIt = parents.iterator(); parentIt.hasNext();) { final TypeNode parent = parentIt.next(); parent.fixDescendants(id); } descendants.set(id); }
protected final boolean fastAdd(Node n) { if (bits == null) { for (int i = 0; i < nodes.length; i++) { if (nodes[i] == null) { empty = false; nodes[i] = n; return true; } else if (nodes[i] == n) { return false; } } convertToBits(); } boolean ret = bits.set(n.getNumber()); if (ret) { empty = false; } return ret; }
private void refresh_solved() throws TypeException { unsolved = new BitVector(); // solved stays the same for (BitSetIterator varIt = unsolved.iterator(); varIt.hasNext();) { final TypeVariableBV var = typeVariableForId(varIt.next()); if (var.depth() == 0) { if (var.type() == null) { unsolved.set(var.id()); } else { solved.set(var.id()); } } } // validate(); }
private final void doubleSize() { int uniSize = universe.size(); if (array.length * 128 > uniSize) { bits = new BitVector(uniSize); Numberable[] oldArray = array; array = null; for (Numberable element : oldArray) { if (element != null) { bits.set(element.getNumber()); } } } else { Numberable[] oldArray = array; array = new Numberable[array.length * 2]; for (Numberable element : oldArray) { if (element != null) { array[findPosition(element)] = element; } } } }
private void fixAncestors() { BitVector ancestors = new BitVector(0); BitVector indirectAncestors = new BitVector(0); for (TypeVariable typeVariable : parents) { TypeVariable parent = typeVariable.ecr(); if (parent.ancestors == null) { parent.fixAncestors(); } ancestors.set(parent.id); ancestors.or(parent.ancestors); indirectAncestors.or(parent.ancestors); } this.ancestors = ancestors; this.indirectAncestors = indirectAncestors; }
single_soft_parent.set(var.id()); } else if (size == 1) { TypeVariableBV parent = typeVariableForId(parents.iterator().next()); single_soft_parent.set(var.id()); } else { single_hard_parent.set(var.id()); multiple_parents.set(var.id()); single_null_child.set(var.id()); } else if (size == 1) { TypeVariableBV child = typeVariableForId(children.iterator().next()); single_null_child.set(var.id()); } else { single_child_not_null.set(var.id()); multiple_children.set(var.id());
final private BitVector makeMaskOfInterface(SootClass interf) { if (!(interf.isInterface())) { throw new RuntimeException(); } BitVector ret = new BitVector(pag.getAllocNodeNumberer().size()); typeMask.put(interf.getType(), ret); Collection<SootClass> implementers = getFastHierarchy().getAllImplementersOfInterface(interf); for (SootClass impl : implementers) { BitVector other = typeMask.get(impl.getType()); if (other == null) { other = makeClassTypeMask(impl); } ret.or(other); } // I think, the following can be eliminated. It is added to make // type-masks exactly the same as the original type-masks if (implementers.size() == 0) { for (AllocNode an : anySubtypeAllocs) { ret.set(an.getNumber()); } } return ret; }
private void fixAncestors() { BitVector ancestors = new BitVector(0); BitVector indirectAncestors = new BitVector(0); fixParents(); for (BitSetIterator i = parents.iterator(); i.hasNext();) { TypeVariableBV parent = resolver.typeVariableForId(i.next()).ecr(); if (parent.ancestors == null) { parent.fixAncestors(); } ancestors.set(parent.id); ancestors.or(parent.ancestors); indirectAncestors.or(parent.ancestors); } this.ancestors = ancestors; this.indirectAncestors = indirectAncestors; }
public void removeIndirectRelations() { if (rep != this) { ecr().removeIndirectRelations(); return; } if (indirectAncestors == null) { fixAncestors(); } BitVector parentsToRemove = new BitVector(); for (BitSetIterator parentIt = parents.iterator(); parentIt.hasNext();) { final int parent = parentIt.next(); if (indirectAncestors.get(parent)) { parentsToRemove.set(parent); } } for (BitSetIterator i = parentsToRemove.iterator(); i.hasNext();) { removeParent(resolver.typeVariableForId(i.next())); } }
private void fixParents() { if (rep != this) { ecr().fixParents(); } BitVector invalid = new BitVector(); invalid.or(parents); invalid.and(resolver.invalidIds()); for (BitSetIterator i = invalid.iterator(); i.hasNext();) { parents.set(resolver.typeVariableForId(i.next()).id()); } parents.clear(this.id); parents.clear(this.id()); parents.andNot(invalid); }