private Collection<List<AbstractState>> callTransferRelation(
final CompositeState compositeState,
final CompositePrecision compositePrecision,
final CFAEdge cfaEdge)
throws CPATransferException, InterruptedException {
int resultCount = 1;
List<AbstractState> componentElements = compositeState.getWrappedStates();
checkArgument(
componentElements.size() == size, "State with wrong number of component states given");
List<Collection<? extends AbstractState>> allComponentsSuccessors = new ArrayList<>(size);
for (int i = 0; i < size; i++) {
TransferRelation lCurrentTransfer = transferRelations.get(i);
AbstractState lCurrentElement = componentElements.get(i);
Precision lCurrentPrecision = compositePrecision.get(i);
Collection<? extends AbstractState> componentSuccessors;
componentSuccessors =
lCurrentTransfer.getAbstractSuccessorsForEdge(
lCurrentElement, lCurrentPrecision, cfaEdge);
resultCount *= componentSuccessors.size();
if (resultCount == 0) {
// shortcut
break;
}
allComponentsSuccessors.add(componentSuccessors);
}
// create cartesian product of all elements we got
return createCartesianProduct(allComponentsSuccessors, resultCount);
}
@Override
public Collection<ARGState> getAbstractSuccessors(AbstractState pElement, Precision pPrecision)
throws CPATransferException, InterruptedException {
ARGState element = (ARGState) pElement;
// covered elements may be in the reached set, but should always be ignored
if (element.isCovered()) {
return Collections.emptySet();
}
element.markExpanded();
AbstractState wrappedState = element.getWrappedState();
Collection<? extends AbstractState> successors =
transferRelation.getAbstractSuccessors(wrappedState, pPrecision);
if (successors.isEmpty()) {
return Collections.emptySet();
}
Collection<ARGState> wrappedSuccessors = new ArrayList<>();
for (AbstractState absElement : successors) {
ARGState successorElem = new ARGState(absElement, element);
wrappedSuccessors.add(successorElem);
}
return wrappedSuccessors;
}
private Collection<List<AbstractState>> callStrengthen(
final List<AbstractState> reachedState,
final CompositePrecision compositePrecision,
final CFAEdge cfaEdge)
throws CPATransferException, InterruptedException {
List<Collection<? extends AbstractState>> lStrengthenResults = new ArrayList<>(size);
int resultCount = 1;
for (int i = 0; i < size; i++) {
TransferRelation lCurrentTransfer = transferRelations.get(i);
AbstractState lCurrentElement = reachedState.get(i);
Precision lCurrentPrecision = compositePrecision.get(i);
Collection<? extends AbstractState> lResultsList =
lCurrentTransfer.strengthen(lCurrentElement, reachedState, cfaEdge, lCurrentPrecision);
if (lResultsList == null) {
lStrengthenResults.add(Collections.singleton(lCurrentElement));
} else {
resultCount *= lResultsList.size();
if (resultCount == 0) {
// shortcut
break;
}
lStrengthenResults.add(lResultsList);
}
}
// special case handling if we have predicate and assumption cpas
// TODO remove as soon as we call strengthen in a fixpoint loop
if (predicatesIndex >= 0 && assumptionIndex >= 0 && resultCount > 0) {
AbstractState predElement = Iterables.getOnlyElement(lStrengthenResults.get(predicatesIndex));
AbstractState assumptionElement =
Iterables.getOnlyElement(lStrengthenResults.get(assumptionIndex));
Precision predPrecision = compositePrecision.get(predicatesIndex);
TransferRelation predTransfer = transferRelations.get(predicatesIndex);
Collection<? extends AbstractState> predResult =
predTransfer.strengthen(
predElement, Collections.singletonList(assumptionElement), cfaEdge, predPrecision);
resultCount *= predResult.size();
lStrengthenResults.set(predicatesIndex, predResult);
}
// create cartesian product
Collection<List<AbstractState>> strengthenedStates =
createCartesianProduct(lStrengthenResults, resultCount);
// If state was not a target state before but a target state was found during strengthening,
// we call strengthen again such that the other CPAs can act on this information.
// Note that this terminates because in the inner call the input state
// is already a target state and this branch won't be taken.
// TODO Generalize this into a full fixpoint algorithm.
if (!any(reachedState, IS_TARGET_STATE)) {
Collection<List<AbstractState>> newStrengthenedStates = new ArrayList<>(resultCount);
for (List<AbstractState> strengthenedState : strengthenedStates) {
if (any(strengthenedState, IS_TARGET_STATE)) {
newStrengthenedStates.addAll(
callStrengthen(strengthenedState, compositePrecision, cfaEdge));
} else {
newStrengthenedStates.add(strengthenedState);
}
}
return newStrengthenedStates;
} else {
return strengthenedStates;
}
}