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;
}
/** creates a new node entry in the VBC output file */
SCIP_RETCODE SCIPvbcNewChild(
SCIP_VBC* vbc, /**< VBC information */
SCIP_STAT* stat, /**< problem statistics */
SCIP_NODE* node /**< new node, that was created */
)
{
SCIP_VAR* branchvar;
SCIP_BOUNDTYPE branchtype;
SCIP_Real branchbound;
size_t parentnodenum;
size_t nodenum;
assert(vbc != NULL);
assert(stat != NULL);
assert(node != NULL);
/* check, if VBC output should be created */
if( vbc->file == NULL )
return SCIP_OKAY;
/* vbc is disabled on probing nodes */
if( SCIPnodeGetType(node) == SCIP_NODETYPE_PROBINGNODE )
return SCIP_OKAY;
/* insert mapping node -> nodenum into hash map */
if( stat->ncreatednodesrun >= (SCIP_Longint)INT_MAX )
{
SCIPerrorMessage("too many nodes to store in the VBC file\n");
return SCIP_INVALIDDATA;
}
nodenum = (size_t)stat->ncreatednodesrun;
assert(nodenum > 0);
SCIP_CALL( SCIPhashmapInsert(vbc->nodenum, node, (void*)nodenum) );
/* get nodenum of parent node from hash map */
parentnodenum = (node->parent != NULL ? (size_t)SCIPhashmapGetImage(vbc->nodenum, node->parent) : 0);
assert(node->parent == NULL || parentnodenum > 0);
/* get branching information */
getBranchInfo(node, &branchvar, &branchtype, &branchbound);
printTime(vbc, stat);
SCIPmessageFPrintInfo(vbc->messagehdlr, vbc->file, "N %d %d %d\n", (int)parentnodenum, (int)nodenum, SCIP_VBCCOLOR_UNSOLVED);
printTime(vbc, stat);
if( branchvar != NULL )
{
SCIPmessageFPrintInfo(vbc->messagehdlr, vbc->file, "I %d \\inode:\\t%d (%p)\\idepth:\\t%d\\nvar:\\t%s [%g,%g] %s %f\\nbound:\\t%f\n",
(int)nodenum, (int)nodenum, node, SCIPnodeGetDepth(node),
SCIPvarGetName(branchvar), SCIPvarGetLbLocal(branchvar), SCIPvarGetUbLocal(branchvar),
branchtype == SCIP_BOUNDTYPE_LOWER ? ">=" : "<=", branchbound, SCIPnodeGetLowerbound(node));
}
else
{
SCIPmessageFPrintInfo(vbc->messagehdlr, vbc->file, "I %d \\inode:\\t%d (%p)\\idepth:\\t%d\\nvar:\\t-\\nbound:\\t%f\n",
(int)nodenum, (int)nodenum, node, SCIPnodeGetDepth(node), SCIPnodeGetLowerbound(node));
}
return SCIP_OKAY;
}
/** marks node as solved in visualization output file */
void SCIPvisualSolvedNode(
SCIP_VISUAL* visual, /**< visualization information */
SCIP_SET* set, /**< global SCIP settings */
SCIP_STAT* stat, /**< problem statistics */
SCIP_NODE* node /**< node, that was solved */
)
{
SCIP_VAR* branchvar;
SCIP_BOUNDTYPE branchtype;
SCIP_Real branchbound;
SCIP_Real lowerbound;
size_t nodenum;
assert( visual != NULL );
assert( stat != NULL );
assert( node != NULL );
/* check whether output should be created */
if ( visual->vbcfile == NULL && visual->bakfile == NULL )
return;
/* visualization is disabled on probing nodes */
if( SCIPnodeGetType(node) == SCIP_NODETYPE_PROBINGNODE )
return;
/* get node num from hash map */
nodenum = (size_t)SCIPhashmapGetImage(visual->nodenum, node);
assert(nodenum > 0);
/* get branching information */
getBranchInfo(node, &branchvar, &branchtype, &branchbound);
/* determine lower bound */
if ( set->visual_objextern )
lowerbound = SCIPretransformObj(set->scip, SCIPnodeGetLowerbound(node));
else
lowerbound = SCIPnodeGetLowerbound(node);
if ( visual->vbcfile != NULL )
{
printTime(visual, stat, TRUE);
if( branchvar != NULL )
{
SCIPmessageFPrintInfo(visual->messagehdlr, visual->vbcfile, "I %d \\inode:\\t%d (%p)\\idepth:\\t%d\\nvar:\\t%s [%g,%g] %s %f\\nbound:\\t%f\\nnr:\\t%" SCIP_LONGINT_FORMAT "\n",
(int)nodenum, (int)nodenum, node, SCIPnodeGetDepth(node),
SCIPvarGetName(branchvar), SCIPvarGetLbLocal(branchvar), SCIPvarGetUbLocal(branchvar),
branchtype == SCIP_BOUNDTYPE_LOWER ? ">=" : "<=", branchbound, lowerbound, stat->nnodes);
}
else
{
SCIPmessageFPrintInfo(visual->messagehdlr, visual->vbcfile, "I %d \\inode:\\t%d (%p)\\idepth:\\t%d\\nvar:\\t-\\nbound:\\t%f\\nnr:\\t%" SCIP_LONGINT_FORMAT "\n",
(int)nodenum, (int)nodenum, node, SCIPnodeGetDepth(node), lowerbound, stat->nnodes);
}
vbcSetColor(visual, stat, node, SCIP_VBCCOLOR_SOLVED);
}
/* do nothing for BAK */
}
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;
}
/** changes the color of the node to the color of solved nodes */
void SCIPvbcSolvedNode(
SCIP_VBC* vbc, /**< VBC information */
SCIP_STAT* stat, /**< problem statistics */
SCIP_NODE* node /**< node, that was solved */
)
{
SCIP_VAR* branchvar;
SCIP_BOUNDTYPE branchtype;
SCIP_Real branchbound;
size_t nodenum;
assert(vbc != NULL);
assert(stat != NULL);
assert(node != NULL);
/* check, if VBC output should be created */
if( vbc->file == NULL )
return;
/* vbc is disabled on probing nodes */
if( SCIPnodeGetType(node) == SCIP_NODETYPE_PROBINGNODE )
return;
/* get node num from hash map */
nodenum = (size_t)SCIPhashmapGetImage(vbc->nodenum, node);
assert(nodenum > 0);
/* get branching information */
getBranchInfo(node, &branchvar, &branchtype, &branchbound);
printTime(vbc, stat);
if( branchvar != NULL )
{
SCIPmessageFPrintInfo(vbc->messagehdlr, vbc->file, "I %d \\inode:\\t%d (%p)\\idepth:\\t%d\\nvar:\\t%s [%g,%g] %s %f\\nbound:\\t%f\\nnr:\\t%"SCIP_LONGINT_FORMAT"\n",
(int)nodenum, (int)nodenum, node, SCIPnodeGetDepth(node),
SCIPvarGetName(branchvar), SCIPvarGetLbLocal(branchvar), SCIPvarGetUbLocal(branchvar),
branchtype == SCIP_BOUNDTYPE_LOWER ? ">=" : "<=", branchbound, SCIPnodeGetLowerbound(node), stat->nnodes);
}
else
{
SCIPmessageFPrintInfo(vbc->messagehdlr, vbc->file, "I %d \\inode:\\t%d (%p)\\idepth:\\t%d\\nvar:\\t-\\nbound:\\t%f\\nnr:\\t%"SCIP_LONGINT_FORMAT"\n",
(int)nodenum, (int)nodenum, node, SCIPnodeGetDepth(node), SCIPnodeGetLowerbound(node), stat->nnodes);
}
vbcSetColor(vbc, stat, node, SCIP_VBCCOLOR_SOLVED);
}
MipsOpcodeInfo GetOpcodeInfo(DebugInterface* cpu, u32 address) {
MipsOpcodeInfo info;
memset(&info, 0, sizeof(info));
if (cpu->isValidAddress(address) == false) {
return info;
}
info.cpu = cpu;
info.opcodeAddress = address;
info.encodedOpcode = cpu->read32(address);
u32 op = info.encodedOpcode;
if (getBranchInfo(info) == true)
return info;
if (getDataAccessInfo(info) == true)
return info;
// gather relevant address for alu operations
// that's usually the value of the dest register
switch (MIPS_GET_OP(op)) {
case 0: // special
switch (MIPS_GET_FUNC(op)) {
case 0x20: // add
case 0x21: // addu
info.hasRelevantAddress = true;
info.releventAddress = cpu->getRegister(0,MIPS_GET_RS(op))._u32[0]+cpu->getRegister(0,MIPS_GET_RT(op))._u32[0];
break;
case 0x22: // sub
case 0x23: // subu
info.hasRelevantAddress = true;
info.releventAddress = cpu->getRegister(0,MIPS_GET_RS(op))._u32[0]-cpu->getRegister(0,MIPS_GET_RT(op))._u32[0];
break;
}
break;
case 0x08: // addi
case 0x09: // adiu
info.hasRelevantAddress = true;
info.releventAddress = cpu->getRegister(0,MIPS_GET_RS(op))._u32[0]+((s16)(op & 0xFFFF));
break;
}
// TODO: rest
/* // movn, movz
if (opInfo & IS_CONDMOVE) {
info.isConditional = true;
u32 rt = cpu->GetRegValue(0, (int)MIPS_GET_RT(op));
switch (opInfo & CONDTYPE_MASK) {
case CONDTYPE_EQ:
info.conditionMet = (rt == 0);
break;
case CONDTYPE_NE:
info.conditionMet = (rt != 0);
break;
}
}*/
return info;
}
/** changes the color of the node to the color of nodes with a primal solution */
void SCIPvisualFoundSolution(
SCIP_VISUAL* visual, /**< visualization information */
SCIP_SET* set, /**< global SCIP settings */
SCIP_STAT* stat, /**< problem statistics */
SCIP_NODE* node, /**< node where the solution was found, or NULL */
SCIP_Bool bettersol, /**< the solution was better than the previous ones */
SCIP_SOL* sol /**< solution that has been found */
)
{
if ( visual->vbcfile != NULL )
{
if ( node != NULL && set->visual_dispsols )
{
if ( SCIPnodeGetType(node) != SCIP_NODETYPE_PROBINGNODE )
vbcSetColor(visual, stat, node, SCIP_VBCCOLOR_SOLUTION);
}
}
if ( visual->bakfile != NULL && bettersol )
{
SCIP_Real obj;
if ( set->visual_objextern )
obj = SCIPgetSolOrigObj(set->scip, sol);
else
obj = SCIPgetSolTransObj(set->scip, sol);
if ( SCIPsolGetHeur(sol) == NULL && node != NULL )
{
/* if LP solution was feasible ... */
SCIP_VAR* branchvar;
SCIP_BOUNDTYPE branchtype;
SCIP_Real branchbound;
SCIP_NODE *pnode;
size_t parentnodenum;
size_t nodenum;
char t = 'M';
/* find first parent that is not a probing node */
pnode = node;
while ( pnode != NULL && SCIPnodeGetType(pnode) == SCIP_NODETYPE_PROBINGNODE )
pnode = pnode->parent;
if ( pnode != NULL )
{
/* get node num from hash map */
nodenum = (size_t)SCIPhashmapGetImage(visual->nodenum, pnode);
/* get nodenum of parent node from hash map */
parentnodenum = (pnode->parent != NULL ? (size_t)SCIPhashmapGetImage(visual->nodenum, pnode->parent) : 0);
assert( pnode->parent == NULL || parentnodenum > 0 );
/* get branching information */
getBranchInfo(pnode, &branchvar, &branchtype, &branchbound);
/* determine branching type */
if ( branchvar != NULL )
t = (branchtype == SCIP_BOUNDTYPE_LOWER ? 'R' : 'L');
printTime(visual, stat, FALSE);
SCIPmessageFPrintInfo(visual->messagehdlr, visual->bakfile, "integer %d %d %c %f\n", (int)nodenum, (int)parentnodenum, t, obj);
}
}
else
{
printTime(visual, stat, FALSE);
SCIPmessageFPrintInfo(visual->messagehdlr, visual->bakfile, "heuristic %f\n", obj);
}
}
}
/** changes the color of the node to the color of cutoff nodes */
void SCIPvisualCutoffNode(
SCIP_VISUAL* visual, /**< visualization information */
SCIP_SET* set, /**< global SCIP settings */
SCIP_STAT* stat, /**< problem statistics */
SCIP_NODE* node, /**< node, that was cut off */
SCIP_Bool infeasible /**< whether the node is infeasible (otherwise exceeded the cutoff bound) */
)
{
SCIP_VAR* branchvar;
SCIP_BOUNDTYPE branchtype;
SCIP_Real branchbound;
SCIP_Real lowerbound;
size_t nodenum;
assert( visual != NULL );
assert( stat != NULL );
assert( node != NULL );
/* check whether output should be created */
if ( visual->vbcfile == NULL && visual->bakfile == NULL )
return;
/* visualization is disabled on probing nodes */
if( SCIPnodeGetType(node) == SCIP_NODETYPE_PROBINGNODE )
return;
/* get node num from hash map */
nodenum = (size_t)SCIPhashmapGetImage(visual->nodenum, node);
assert(nodenum > 0);
/* get branching information */
getBranchInfo(node, &branchvar, &branchtype, &branchbound);
/* determine lower bound */
if ( set->visual_objextern )
lowerbound = SCIPretransformObj(set->scip, SCIPnodeGetLowerbound(node));
else
lowerbound = SCIPnodeGetLowerbound(node);
if ( visual->vbcfile != NULL )
{
printTime(visual, stat, TRUE);
if( branchvar != NULL )
{
SCIPmessageFPrintInfo(visual->messagehdlr, visual->vbcfile, "I %d \\inode:\\t%d (%p)\\idepth:\\t%d\\nvar:\\t%s [%g,%g] %s %f\\nbound:\\t%f\\nnr:\\t%" SCIP_LONGINT_FORMAT "\n",
(int)nodenum, (int)nodenum, node, SCIPnodeGetDepth(node),
SCIPvarGetName(branchvar), SCIPvarGetLbLocal(branchvar), SCIPvarGetUbLocal(branchvar),
branchtype == SCIP_BOUNDTYPE_LOWER ? ">=" : "<=", branchbound, lowerbound, stat->nnodes);
}
else
{
SCIPmessageFPrintInfo(visual->messagehdlr, visual->vbcfile, "I %d \\inode:\\t%d (%p)\\idepth:\\t%d\\nvar:\\t-\\nbound:\\t%f\\nnr:\\t%" SCIP_LONGINT_FORMAT "\n",
(int)nodenum, (int)nodenum, node, SCIPnodeGetDepth(node), lowerbound, stat->nnodes);
}
vbcSetColor(visual, stat, node, SCIP_VBCCOLOR_CUTOFF);
}
if ( visual->bakfile != NULL )
{
size_t parentnodenum;
char t = 'M';
/* determine branching type */
if ( branchvar != NULL )
t = (branchtype == SCIP_BOUNDTYPE_LOWER ? 'R' : 'L');
/* get nodenum of parent node from hash map */
parentnodenum = (node->parent != NULL ? (size_t)SCIPhashmapGetImage(visual->nodenum, node->parent) : 0);
assert(node->parent == NULL || parentnodenum > 0);
printTime(visual, stat, FALSE);
if ( infeasible )
SCIPmessageFPrintInfo(visual->messagehdlr, visual->bakfile, "infeasible %d %d %c\n", (int)nodenum, (int)parentnodenum, t);
else
SCIPmessageFPrintInfo(visual->messagehdlr, visual->bakfile, "fathomed %d %d %c\n", (int)nodenum, (int)parentnodenum, t);
}
}
/** updates a node entry in the visualization output file */
SCIP_RETCODE SCIPvisualUpdateChild(
SCIP_VISUAL* visual, /**< visualization information */
SCIP_SET* set, /**< global SCIP settings */
SCIP_STAT* stat, /**< problem statistics */
SCIP_NODE* node /**< new node, that was created */
)
{
SCIP_VAR* branchvar;
SCIP_BOUNDTYPE branchtype;
SCIP_Real branchbound;
SCIP_Real lowerbound;
size_t nodenum;
assert( visual != NULL );
assert( stat != NULL );
assert( node != NULL );
/* check whether output should be created */
if ( visual->vbcfile == NULL && visual->bakfile == NULL )
return SCIP_OKAY;
/* visualization is disabled on probing nodes */
if( SCIPnodeGetType(node) == SCIP_NODETYPE_PROBINGNODE )
return SCIP_OKAY;
/* get node num from hash map */
nodenum = (size_t)SCIPhashmapGetImage(visual->nodenum, node);
assert(nodenum > 0);
/* get branching information */
getBranchInfo(node, &branchvar, &branchtype, &branchbound);
/* determine lower bound */
if ( set->visual_objextern )
lowerbound = SCIPretransformObj(set->scip, SCIPnodeGetLowerbound(node));
else
lowerbound = SCIPnodeGetLowerbound(node);
if ( visual->vbcfile != NULL )
{
printTime(visual, stat, TRUE);
if( branchvar != NULL )
{
SCIPmessageFPrintInfo(visual->messagehdlr, visual->vbcfile, "I %d \\inode:\\t%d (%p)\\idepth:\\t%d\\nvar:\\t%s [%g,%g] %s %f\\nbound:\\t%f\n",
(int)nodenum, (int)nodenum, node, SCIPnodeGetDepth(node),
SCIPvarGetName(branchvar), SCIPvarGetLbLocal(branchvar), SCIPvarGetUbLocal(branchvar),
branchtype == SCIP_BOUNDTYPE_LOWER ? ">=" : "<=", branchbound, lowerbound);
}
else
{
SCIPmessageFPrintInfo(visual->messagehdlr, visual->vbcfile, "I %d \\inode:\\t%d (%p)\\idepth:\\t%d\\nvar:\\t-\\nbound:\\t%f\n",
(int)nodenum, (int)nodenum, node, SCIPnodeGetDepth(node), lowerbound);
}
}
if ( visual->bakfile != NULL )
{
size_t parentnodenum;
SCIP_Real* lpcandsfrac;
SCIP_Real sum = 0.0;
int nlpcands = 0;
char t = 'M';
const char* nodeinfo;
int j;
/* determine branching type */
if ( branchvar != NULL )
t = (branchtype == SCIP_BOUNDTYPE_LOWER ? 'R' : 'L');
/* get nodenum of parent node from hash map */
parentnodenum = (node->parent != NULL ? (size_t)SCIPhashmapGetImage(visual->nodenum, node->parent) : 0);
assert(node->parent == NULL || parentnodenum > 0);
/* update info depending on the node type */
switch( SCIPnodeGetType(node) )
{
case SCIP_NODETYPE_CHILD:
/* the child is a new candidate */
nodeinfo = "candidate";
break;
case SCIP_NODETYPE_FOCUSNODE:
/* the focus node is updated to a branch node */
nodeinfo = "branched";
/* calculate infeasibility information */
SCIP_CALL( SCIPgetLPBranchCands(set->scip, NULL, NULL, &lpcandsfrac, &nlpcands, NULL, NULL) );
for (j = 0; j < nlpcands; ++j)
sum += lpcandsfrac[j];
break;
default:
SCIPerrorMessage("Error: Unexpected node type <%d> in Update Child Method", SCIPnodeGetType(node));
return SCIP_INVALIDDATA;
} /*lint !e788*/
/* append new status line with updated node information to the bakfile */
printTime(visual, stat, FALSE);
SCIPmessageFPrintInfo(visual->messagehdlr, visual->bakfile, "%s %d %d %c %f %f %d\n", nodeinfo, (int)nodenum, (int)parentnodenum, t,
lowerbound, sum, nlpcands);
}
return SCIP_OKAY;
}
/** creates a new node entry in the visualization output file */
SCIP_RETCODE SCIPvisualNewChild(
SCIP_VISUAL* visual, /**< visualization information */
SCIP_SET* set, /**< global SCIP settings */
SCIP_STAT* stat, /**< problem statistics */
SCIP_NODE* node /**< new node, that was created */
)
{
SCIP_VAR* branchvar;
SCIP_BOUNDTYPE branchtype;
SCIP_Real branchbound;
SCIP_Real lowerbound;
size_t parentnodenum;
size_t nodenum;
assert( visual != NULL );
assert( stat != NULL );
assert( node != NULL );
/* visualization is disabled on probing nodes */
if( SCIPnodeGetType(node) == SCIP_NODETYPE_PROBINGNODE )
return SCIP_OKAY;
/* check whether output should be created */
if ( visual->vbcfile == NULL && visual->bakfile == NULL )
return SCIP_OKAY;
/* insert mapping node -> nodenum into hash map */
if( stat->ncreatednodesrun >= (SCIP_Longint)INT_MAX )
{
SCIPerrorMessage("too many nodes to store in the visualization file\n");
return SCIP_INVALIDDATA;
}
nodenum = (size_t)stat->ncreatednodesrun;
assert(nodenum > 0);
SCIP_CALL( SCIPhashmapInsert(visual->nodenum, node, (void*)nodenum) );
/* get nodenum of parent node from hash map */
parentnodenum = (node->parent != NULL ? (size_t)SCIPhashmapGetImage(visual->nodenum, node->parent) : 0);
assert(node->parent == NULL || parentnodenum > 0);
/* get branching information */
getBranchInfo(node, &branchvar, &branchtype, &branchbound);
/* determine lower bound */
if ( set->visual_objextern )
lowerbound = SCIPretransformObj(set->scip, SCIPnodeGetLowerbound(node));
else
lowerbound = SCIPnodeGetLowerbound(node);
if ( visual->vbcfile != NULL )
{
printTime(visual, stat, TRUE);
SCIPmessageFPrintInfo(visual->messagehdlr, visual->vbcfile, "N %d %d %d\n", (int)parentnodenum, (int)nodenum, SCIP_VBCCOLOR_UNSOLVED);
printTime(visual, stat, TRUE);
if( branchvar != NULL )
{
SCIPmessageFPrintInfo(visual->messagehdlr, visual->vbcfile, "I %d \\inode:\\t%d (%p)\\idepth:\\t%d\\nvar:\\t%s [%g,%g] %s %f\\nbound:\\t%f\n",
(int)nodenum, (int)nodenum, node, SCIPnodeGetDepth(node),
SCIPvarGetName(branchvar), SCIPvarGetLbLocal(branchvar), SCIPvarGetUbLocal(branchvar),
branchtype == SCIP_BOUNDTYPE_LOWER ? ">=" : "<=", branchbound, lowerbound);
}
else
{
SCIPmessageFPrintInfo(visual->messagehdlr, visual->vbcfile, "I %d \\inode:\\t%d (%p)\\idepth:\\t%d\\nvar:\\t-\\nbound:\\t%f\n",
(int)nodenum, (int)nodenum, node, SCIPnodeGetDepth(node), lowerbound);
}
}
/* For BAK, not all available information is available here. Use SCIPvisualUpdateChild() instead */
return SCIP_OKAY;
}
CDGPath *getTopPaths(CDGContext * ctx, CDGNode * root, int numberOfPaths) {
CDGPath *pathHead = NULL;
CDGNode *path;
CDGPath *currPath;
CDGNode *node;
int branch;
Stack *changedNodes = stackNew(sizeof(CDGNode *));
Stack *changedBranches = stackNew(sizeof(int));
while (numberOfPaths--) {
path = getTopPath(root, changedNodes, changedBranches);
if (NULL == path)
break;
if (NULL == pathHead) {
pathHead = setPathNode(newPath(), path);
currPath = pathHead;
} else {
setNextPath(currPath, setPathNode(newPath(), path));
currPath = getNextPath(currPath);
}
updateCDG(root, 0);
}
while (!stackIsEmpty(changedNodes) && !stackIsEmpty(changedBranches)) {
stackPop(changedNodes, &node);
stackPop(changedBranches, &branch);
if (isLeaf(node)) {
setScore(node, 1);
} else {
if (branch)
setBranchInfo(getID(node), 0, getBranchInfo(getID(node), 0));
else
setBranchInfo(getID(node), getBranchInfo(getID(node), 1), 0);
}
}
updateCDG(root, 0);
stackFree(changedNodes);
stackFree(changedBranches);
/* Updating context */
(*ctx).topPaths = pathHead;
/* Ensuring atleast one path was found */
if (NULL == pathHead)
return NULL;
/* Creating list of nodes from complicated path form */
CDGPath *outPathHead = NULL;
currPath = NULL;
path = NULL;
while (NULL != pathHead) {
path = getPathNode(pathHead);
if (NULL == outPathHead) {
outPathHead = setPathNode(newPath(), pathToList(path));
currPath = outPathHead;
} else {
setNextPath(currPath, setPathNode(newPath(), pathToList(path)));
currPath = getNextPath(currPath);
}
pathHead = getNextPath(pathHead);
}
return outPathHead;
}
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;
}