int main(int argc, char *argv[])
{
struct tree at;
int op,lr,parent,child;
initTree(&at);
while(scanf("%d",&op)==1 && op!=0){
switch(op){
case 1://insert node
scanf("%d%d%d",&parent,&lr,&child);
printf("insert node(p=%d lr=%d c=%d):",parent,lr,child);
if(insertTreeNode(&at,parent,lr,child)){
printf("success\n");
}else{
printf("fail\n");
}
break;
case 2://breadfirst traversal
printf("breadthfirst:");
breadthFirstTraversal(&at);
printf("\n");
break;
case 3://pre order traversal
printf("depth preorder:");
depthFirstTraversal(&at,PREORDER);
printf("\n");
break;
case 4://in order traversal
printf("depth inorder:");
depthFirstTraversal(&at,INORDER);
printf("\n");
break;
case 5://post order traversal
printf("depth postorder:");
depthFirstTraversal(&at,POSTORDER);
printf("\n");
break;
default:
printf("error operator\n");
break;
}
}
releaseTree(&at);
return 0;
}
void depthFirstTraversal(jitdata* jd, basicblock* block)
{
block->ld->semi = ++jd->ld->n;
jd->ld->vertex.push_back(block);
block->ld->label = block;
// Check if jd->ld->vertex[jd->ld->n] == block
assert(static_cast<s4>(jd->ld->vertex.size()) == jd->ld->n + 1);
for (s4 i = 0; i < block->successorcount; i++)
{
basicblock* successor = block->successors[i];
if (successor->ld->semi == 0) // visited the first time?
{
successor->ld->parent = block;
depthFirstTraversal(jd, successor);
}
else // back edge found
{
jd->ld->depthBackEdges.push_back(Edge(block, successor));
}
successor->ld->pred.push_back(block);
}
}
/**
* Calculates the immediate dominators of all basicblocks.
*/
void calculateDominators(jitdata* jd)
{
assert(jd->ld->root);
/******************
* Step 1 *
******************/
// Insert an arbitrary element so that the first real item has index 1. This simplifies the implementation.
jd->ld->vertex.push_back(0);
assert(jd->ld->vertex.size() == 1);
for (basicblock* block = jd->basicblocks; block != 0; block = block->next)
{
block->ld = new BasicblockLoopData;
}
// jd->ld->root is not contained in the linked list jd->basicblocks.
jd->ld->root->ld = new BasicblockLoopData;
depthFirstTraversal(jd, jd->ld->root);
assert(static_cast<s4>(jd->ld->vertex.size()) == jd->ld->n + 1);
for (s4 i = jd->ld->n; i >= 2; i--)
{
basicblock* w = jd->ld->vertex[i];
/******************
* Step 2 *
******************/
typedef std::vector<basicblock*>::iterator Iterator;
for (Iterator it = w->ld->pred.begin(); it != w->ld->pred.end(); ++it)
{
basicblock* v = *it;
basicblock* u = eval(v);
if (u->ld->semi < w->ld->semi)
w->ld->semi = u->ld->semi;
}
jd->ld->vertex[w->ld->semi]->ld->bucket.push_back(w);
link(w->ld->parent, w);
/******************
* Step 3 *
******************/
std::vector<basicblock*>& bucket = w->ld->parent->ld->bucket;
for (Iterator it = bucket.begin(); it != bucket.end(); ++it)
{
basicblock* v = *it;
basicblock* u = eval(v);
if (u->ld->semi < v->ld->semi)
v->ld->dom = u;
else
v->ld->dom = w->ld->parent;
}
bucket.clear();
}
/******************
* Step 4 *
******************/
for (s4 i = 2; i <= jd->ld->n; i++)
{
basicblock* w = jd->ld->vertex[i];
if (w->ld->dom != jd->ld->vertex[w->ld->semi])
w->ld->dom = w->ld->dom->ld->dom;
}
jd->ld->root->ld->dom = 0;
}
int main() {
printf("\nCOMP2000 Assignment 5\n\nStudent # : 812000767\n\n\n\n********** Graph ************* \n\n\n");
FILE*in = fopen("input.txt", "r");
FILE*out = fopen("output.txt", "w");
// part (a)
char word[MaxWordSize] = { '\0' };
int numVertices = 0;
fscanf(in, "%s", &word);
while (strcmp(word,"END") != 0){
numVertices++; // getting the number of vertices's
insertNode(&rootPtr, word);
fscanf(in, "%s", &word);
}
Graph G = newGraph(numVertices);
buildGraph(in, G);
printGraph(out, G);
// end part (a)
printf("-> Part (a) finished ... \n\n");
// part b
fscanf(in, "%s", &word);
search(rootPtr, word);
depthFirstTraversal(out, G, Placement);
breadthFirstTraversal(out, G, Placement);
fscanf(in, "%s", &word);
search(rootPtr, word);
depthFirstTraversal(out, G, Placement);
breadthFirstTraversal(out, G, Placement);
fprintf(out, "\n");
fprintf(out, "\n");
// end part b
printf("-> Part (b) finished ... \n\n");
// part (c)
fscanf(in, "%s", &word);
while (strcmp(word, "END") != 0){
search(rootPtr, word);
fprintf(out, "Minimal cost path from %s:\n", word);
Dijkstra(out, G, Placement, word);
fscanf(in, "%s", &word);
Placement = 0;
fprintf(out, "\n");
}
// end part (c)
printf("-> Part (c) finished ... \n\n");
Placement = j = order = 0;
fclose(in);
fclose(out);
printf("********* Finished ***********\n\n");
system("PAUSE");
return 0;
}
