private Collection<Edge> getRelevantChildrenOfState(
ARGState currentElement, Stack<FunctionBody> functionStack, Set<ARGState> elementsOnPath) {
// find the next elements to add to the waitlist
List<ARGState> relevantChildrenOfElement =
from(currentElement.getChildren()).filter(in(elementsOnPath)).toList();
relevantChildrenOfElement = chooseIfArbitrary(currentElement, relevantChildrenOfElement);
// if there is only one child on the path
if (relevantChildrenOfElement.size() == 1) {
// get the next ARG state, create a new edge using the same stack and add it to the waitlist
ARGState elem = Iterables.getOnlyElement(relevantChildrenOfElement);
CFAEdge e = currentElement.getEdgeToChild(elem);
Edge newEdge = new Edge(elem, currentElement, e, functionStack);
return Collections.singleton(newEdge);
} else if (relevantChildrenOfElement.size() > 1) {
// if there are more than one relevant child, then this is a condition
// we need to update the stack
assert relevantChildrenOfElement.size() == 2;
Collection<Edge> result = new ArrayList<>(2);
int ind = 0;
for (ARGState elem : relevantChildrenOfElement) {
Stack<FunctionBody> newStack = cloneStack(functionStack);
CFAEdge e = currentElement.getEdgeToChild(elem);
FunctionBody currentFunction = newStack.peek();
assert e instanceof CAssumeEdge;
CAssumeEdge assumeEdge = (CAssumeEdge) e;
boolean truthAssumption = assumeEdge.getTruthAssumption();
String cond = "";
if (ind == 0) {
cond = "if ";
} else if (ind == 1) {
cond = "else if ";
} else {
throw new AssertionError();
}
ind++;
if (truthAssumption) {
cond += "(" + assumeEdge.getExpression().toASTString() + ")";
} else {
cond += "(!(" + assumeEdge.getExpression().toASTString() + "))";
}
// create a new block starting with this condition
currentFunction.enterBlock(currentElement.getStateId(), assumeEdge, cond);
Edge newEdge = new Edge(elem, currentElement, e, newStack);
result.add(newEdge);
}
return result;
}
return Collections.emptyList();
}
protected String processSimpleEdge(CFAEdge pCFAEdge, BasicBlock currentBlock) {
switch (pCFAEdge.getEdgeType()) {
case BlankEdge:
case StatementEdge:
case ReturnStatementEdge:
return pCFAEdge.getCode();
case AssumeEdge:
{
CAssumeEdge lAssumeEdge = (CAssumeEdge) pCFAEdge;
return ("__CPROVER_assume(" + lAssumeEdge.getCode() + ");");
// return ("if(! (" + lAssumptionString + ")) { return (0); }");
}
case DeclarationEdge:
{
CDeclarationEdge lDeclarationEdge = (CDeclarationEdge) pCFAEdge;
if (lDeclarationEdge.getDeclaration().isGlobal()) {
mGlobalDefinitionsList.add(lDeclarationEdge.getCode());
return "";
}
// avoid having the same declaration edge twice in one basic block
if (currentBlock.hasDeclaration(lDeclarationEdge)) {
return "";
} else {
currentBlock.addDeclaration(lDeclarationEdge);
return lDeclarationEdge.getCode();
}
}
default:
throw new AssertionError(
"Unexpected edge " + pCFAEdge + " of type " + pCFAEdge.getEdgeType());
}
}
