CDGNode *visitAnyOneChild(CDGNode * node) {
CDGNode *child = NULL;
if (getFalseNodeSet(node)) {
child = visitAnyOneNode(getFalseNodeSet(node));
}
if (NULL == child && getTrueNodeSet(node)) {
child = visitAnyOneNode(getTrueNodeSet(node));
}
assert(NULL != child);
return child;
}
CDGNode *addDummyNodes(CDGNode * node) {
while (node) {
if (!isLeaf(node)) {
if (NULL == getTrueNodeSet(node)) {
addTrueNode(node, newBlankNode());
} else if (NULL == getFalseNodeSet(node)) {
addFalseNode(node, newBlankNode());
}
}
addDummyNodes(getTrueNodeSet(node));
addDummyNodes(getFalseNodeSet(node));
node = getNextNode(node);
}
return node;
}
CDGNode *getTopPath(CDGNode * node, Stack * changedNodes, Stack * changedBranches) {
CDGNode *pathNode = newBlankNode();
CDGNode *temp = pathNode;
int branch;
while (node) {
if (0 != getScore(node)) {
stackPush(changedNodes, &node);
branch = getOutcome(node);
stackPush(changedBranches, &branch);
if (isLeaf(node)) {
setScore(node, 0);
} else {
setNextNode(temp, copyToPathNode(newBlankNode(), node));
temp = getNextNode(temp);
if (getOutcome(node)) {
setBranchInfo(getID(node), 1, getBranchInfo(getID(node), 0));
setTrueNodeSet(temp, getTopPath(getTrueNodeSet(node), changedNodes, changedBranches));
} else {
setBranchInfo(getID(node), getBranchInfo(getID(node), 1), 1);
setFalseNodeSet(temp, getTopPath(getFalseNodeSet(node), changedNodes, changedBranches));
}
}
}
node = getNextNode(node);
}
if (temp == pathNode) {
deleteNode(pathNode);
pathNode = NULL;
} else {
temp = pathNode;
pathNode = getNextNode(pathNode);
deleteNode(temp);
}
return pathNode;
}
int hasUncoveredBranch(CDGNode * node, int branch) {
if (branch && NULL == getTrueNodeSet(node))
return 0;
if (0 == branch && NULL == getFalseNodeSet(node))
return 0;
if (0 == getBranchInfo(getID(node), branch))
return 1;
return 0;
}
void postOrder(CDGNode * root, Stack * s) {
if (NULL == root)
return;
Stack *temp = stackNew(sizeof(CDGNode *));;
CDGNode *node;
CDGNode *listNode;
pushNodeListToStack(temp, root);
while (!stackIsEmpty(temp)) {
stackPop(temp, &node);
if (getTrueNodeSet(node)) {
pushNodeListToStack(temp, getTrueNodeSet(node));
}
if (getFalseNodeSet(node)) {
pushNodeListToStack(temp, getFalseNodeSet(node));
}
stackPush(s, &node);
}
stackFree(temp);
}
void preOrderCDG(CDGNode* node) {
while (node) {
if ( 0 == getID(node) )
printf("ID: %d, PID: 0", getID(node));
else
printf("ID: %d, PID: %d", getID(node), getID(getParent(node)));
preOrderCDG(getTrueNodeSet(node));
preOrderCDG(getFalseNodeSet(node));
node = getNextNode(node);
}
}
int isConditionalLeaf(CDGNode * node) {
if (isLeaf(node))
return 0;
if (!hasConditionalChild(node))
return 1;
if (0 < getConditionalNodeSum(getTrueNodeSet(node)))
return 0;
if (0 < getConditionalNodeSum(getFalseNodeSet(node)))
return 0;
return 1;
}
CDGNode *setFalseNodeSetScore(CDGNode * node, int score) {
CDGNode *curr;
curr = getFalseNodeSet(node);
while (curr != NULL) {
setScore(curr, score);
curr = curr->next;
}
return node;
}
int hasUncoveredChild(CDGNode * node, int branch) {
CDGNode *temp;
if (branch)
temp = getTrueNodeSet(node);
else
temp = getFalseNodeSet(node);
while (temp) {
if (isLeaf(temp) && 0 < getScore(temp))
return 1;
temp = getNextNode(temp);
}
return 0;
}
void visitChildren(CDGNode * node, int outcome) {
CDGNode *children;
if (outcome) {
children = getTrueNodeSet(node);
} else {
children = getFalseNodeSet(node);
}
while (children) {
if (isLeaf(children)) {
setScore(children, 0);
}
children = getNextNode(children);
}
return;
}
CDGNode *getMaxScoreConditionChildNode(CDGNode * node, int *outcome) {
CDGNode *maxTrue = NULL;
CDGNode *maxFalse = NULL;
if (getTrueNodeSet(node)) {
maxTrue = getMaxScoreConditionNode(getTrueNodeSet(node));
}
if (getFalseNodeSet(node)) {
maxFalse = getMaxScoreConditionNode(getFalseNodeSet(node));
}
if (NULL == maxFalse) {
*outcome = 1;
return maxTrue;
}
if (NULL == maxTrue) {
*outcome = 0;
return maxFalse;
}
if (getScore(maxTrue) < getScore(maxFalse)) {
*outcome = 0;
return maxFalse;
}
*outcome = 1;
return maxTrue;
}
CDGNode *buildFeasiblePath(CDGNode * node, CDGNode * list) {
while (node && 0 == nodeExists(list, getID(node))) {
node = getNextNode(node);
}
if (NULL == node)
return NULL;
CDGNode *out = NULL;
out = copyToPathNode(newBlankNode(), node);
setTrueNodeSet(out, buildFeasiblePath(getTrueNodeSet(node), list));
setFalseNodeSet(out, buildFeasiblePath(getFalseNodeSet(node), list));
setNextNode(out, buildFeasiblePath(getNextNode(node), list));
return out;
}
int hasConditionalChild(CDGNode * node) {
CDGNode *temp;
temp = getTrueNodeSet(node);
while (temp) {
if (!isLeaf(temp))
return 1;
temp = getNextNode(temp);
}
temp = getFalseNodeSet(node);
while (temp) {
if (!isLeaf(temp))
return 1;
temp = getNextNode(temp);
}
return 0;
}
int isLeaf(CDGNode * node) {
if (getTrueNodeSet(node) || getFalseNodeSet(node))
return 0;
return 1;
}
CDGNode *updateScore(CDGNode * node, int initialize) {
assert(NULL != node);
if (isLeaf(node))
return node;
if (isConditionalLeaf(node)) {
if (initialize) {
if (getBranchInfo(node->id, 1) && !getBranchInfo(node->id, 0)) {
setScore(node, 1);
setTrueNodeSetScore(node, 0);
setFalseNodeSetScore(node, 1);
return setOutcome(node, 0);
} else if (getBranchInfo(node->id, 0) && !getBranchInfo(node->id, 1)) {
setScore(node, 1);
setFalseNodeSetScore(node, 0);
setTrueNodeSetScore(node, 1);
return setOutcome(node, 1);
} else if (getBranchInfo(node->id, 0) && getBranchInfo(node->id, 1)) {
setScore(node, 0);
setTrueNodeSetScore(node, 0);
setFalseNodeSetScore(node, 0);
return setOutcome(node, 1);
}
}
else {
if (hasUncoveredChild(node, 1)) {
setScore(node, 1);
return setOutcome(node, 1);
}
if (hasUncoveredChild(node, 0)) {
setScore(node, 1);
return setOutcome(node, 0);
}
}
setScore(node, 0);
return setOutcome(node, 1);
}
int trueScore = getConditionalNodeSum(getTrueNodeSet(node));
int falseScore = getConditionalNodeSum(getFalseNodeSet(node));
if (trueScore >= falseScore) {
if (node->id == 0) {
setScore(node, trueScore);
setOutcome(node, 1);
}
else {
if (getBranchInfo(node->id, 1) && getBranchInfo(node->id, 0))
setScore(node, trueScore);
else
setScore(node, trueScore + 1);
setOutcome(node, 1);
}
}
else {
if (node->id == 0) {
setScore(node, falseScore);
setOutcome(node, 0);
} else {
if (getBranchInfo(node->id, 1) && getBranchInfo(node->id, 0))
setScore(node, falseScore);
else
setScore(node, falseScore+1);
setOutcome(node, 0);
}
}
return node;
}
