TaskGraph functionality shouldn't be part of TaskAnalysis

diff --git a/Robust/src/Analysis/TaskStateAnalysis/TaskAnalysis.java b/Robust/src/Analysis/TaskStateAnalysis/TaskAnalysis.java
index 20d80a922f73aaf0e60246cb3d49dd5ab0113557..42c07e570765ee0ac43f9577c3b1adf7b5b67e3e 100644 (file)
--- a/Robust/src/Analysis/TaskStateAnalysis/TaskAnalysis.java
+++ b/Robust/src/Analysis/TaskStateAnalysis/TaskAnalysis.java
@@ -1,5 +1,4 @@
 package Analysis.TaskStateAnalysis;
-import Analysis.TaskStateAnalysis.*;
 import IR.*;
 import IR.Tree.*;
 import IR.Flat.*;
@@ -404,11 +403,16 @@ private FlagState evalNewObjNode(FlatNode nn){
                FileOutputStream dotstream=new FileOutputStream(dotfile_flagstates,true);
                FlagState.DOTVisitor.visit(dotstream,((Hashtable)flagstates.get(cd)).values());
                
-               File dotfile_tasknodes=new File("graph"+cd.getSymbol()+"_task.dot");
-               dotstream=new FileOutputStream(dotfile_tasknodes,true);
-               TaskNode.DOTVisitor.visit(dotstream,(produceTaskNodes((Hashtable)flagstates.get(cd))).values());
     }
        
+    /** Returns the flag states for the class descriptor. */
+    public Set getFlagStates(ClassDescriptor cd) {
+       if (flagstates.containsKey(cd))
+           return ((Hashtable)flagstates.get(cd)).keySet();
+       else
+           return null;
+    }
+
 
     private void createPossibleRuntimeStates(FlagState fs) {
     ClassDescriptor cd = fs.getClassDescriptor();
@@ -446,42 +450,7 @@ private FlagState evalNewObjNode(FlatNode nn){
     }
        }
        
-       private TaskNode canonicalizeTaskNode(Hashtable nodes, TaskNode node){
-       if (nodes.containsKey(node))
-           return (TaskNode)nodes.get(node);
-       else{
-           nodes.put(node,node);
-           return (TaskNode)node;
-       }
-    }
-       
-       public Hashtable produceTaskNodes(Hashtable<FlagState,FlagState> fsnodes){
-               
-               Hashtable<TaskNode,TaskNode> tasknodes=new Hashtable<TaskNode,TaskNode>();
-               for(Enumeration en=fsnodes.keys();en.hasMoreElements();){
-                       FlagState fs=(FlagState)en.nextElement();
-                       
-                       Iterator it_inedges=fs.inedges();       
-                       TaskNode tn;
-                       do{
-                               if (!fs.inedges().hasNext()){
-                                       tn=new TaskNode("Start Node");
-                               }else{
-                                       FEdge inedge=(FEdge)it_inedges.next();
-                                       tn=new TaskNode(inedge.getLabel());
-                               }
-                               if(fs.edges().hasNext()){
-                                       tn=(TaskNode)canonicalizeTaskNode(tasknodes, tn);
-                                       for (Iterator it_edges=fs.edges();it_edges.hasNext();){
-                                               TaskNode target=new TaskNode(((FEdge)it_edges.next()).getLabel());
-                                               target=(TaskNode)canonicalizeTaskNode(tasknodes,target);
-                                               tn.addEdge(new TEdge(target));
-                                       }
-                               }
-                       }while(it_inedges.hasNext());
-               }
-               return tasknodes;
-       }
+
        
 } 
 

diff --git a/Robust/src/Analysis/TaskStateAnalysis/TaskGraph.java b/Robust/src/Analysis/TaskStateAnalysis/TaskGraph.java
new file mode 100644 (file)
index 0000000..224738c
--- /dev/null
+++ b/Robust/src/Analysis/TaskStateAnalysis/TaskGraph.java
@@ -0,0 +1,94 @@
+package Analysis.TaskStateAnalysis;
+import java.util.*;
+import IR.State;
+import IR.SymbolTable;
+import IR.ClassDescriptor;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.FileOutputStream;
+
+public class TaskGraph {
+    TaskAnalysis taskanalysis;
+    State state;
+    Hashtable cdtonodes;
+
+    public TaskGraph(State state, TaskAnalysis taskanalysis) {
+       this.state=state;
+       this.taskanalysis=taskanalysis;
+       this.cdtonodes=new Hashtable();
+
+       for(Iterator classit=state.getClassSymbolTable().getDescriptorsIterator();classit.hasNext();) {
+           ClassDescriptor cd=(ClassDescriptor) classit.next();
+           produceTaskNodes(cd);
+       }
+    }
+    
+    
+    public void createDOTfiles() {
+       for(Iterator classit=state.getClassSymbolTable().getDescriptorsIterator();classit.hasNext();) {
+           ClassDescriptor cd=(ClassDescriptor) classit.next();
+           Set tasknodes=getTaskNodes(cd);
+           if (tasknodes!=null) {
+               try {
+                   File dotfile_tasknodes=new File("graph"+cd.getSymbol()+"_task.dot");
+                   FileOutputStream dotstream=new FileOutputStream(dotfile_tasknodes,true);
+                   TaskNode.DOTVisitor.visit(dotstream,tasknodes);
+               } catch(Exception e) {
+                   e.printStackTrace();
+                   throw new Error();
+               }
+           }
+       }
+    }
+
+    /** Returns the set of TaskNodes for the class descriptor cd */
+
+    public Set getTaskNodes(ClassDescriptor cd) {
+       if (cdtonodes.containsKey(cd))
+           return ((Hashtable)cdtonodes.get(cd)).keySet();
+       else
+           return null;
+    }
+
+    private TaskNode canonicalizeTaskNode(Hashtable nodes, TaskNode node){
+       if (nodes.containsKey(node))
+           return (TaskNode)nodes.get(node);
+       else{
+           nodes.put(node,node);
+           return (TaskNode)node;
+       }
+    }
+    
+    private void produceTaskNodes(ClassDescriptor cd) {
+       Set fsnodes=taskanalysis.getFlagStates(cd);
+       if (fsnodes==null)
+           return;
+
+       Hashtable<TaskNode,TaskNode> tasknodes=new Hashtable<TaskNode,TaskNode>();
+       cdtonodes.put(cd, tasknodes);
+
+       for(Iterator it=fsnodes.iterator();it.hasNext();) {
+           FlagState fs=(FlagState)it.next();
+           
+           Iterator it_inedges=fs.inedges();   
+           TaskNode tn;
+           do {
+               if (!fs.inedges().hasNext()){
+                   tn=new TaskNode("Start Node");
+               } else {
+                   FEdge inedge=(FEdge)it_inedges.next();
+                   tn=new TaskNode(inedge.getLabel());
+               }
+               if(fs.edges().hasNext()){
+                   tn=(TaskNode)canonicalizeTaskNode(tasknodes, tn);
+                   for (Iterator it_edges=fs.edges();it_edges.hasNext();){
+                       TaskNode target=new TaskNode(((FEdge)it_edges.next()).getLabel());
+                       target=(TaskNode)canonicalizeTaskNode(tasknodes,target);
+                       tn.addEdge(new TEdge(target));
+                   }
+               }
+           } while(it_inedges.hasNext());
+       }
+    }
+    
+}

diff --git a/Robust/src/Main/Main.java b/Robust/src/Main/Main.java
index f2438e406d41fab6e47086f9d8353475ac869768..ce1a215590b0bced2826f543a777ff36c3fde9f3 100644 (file)
--- a/Robust/src/Main/Main.java
+++ b/Robust/src/Main/Main.java
@@ -11,6 +11,7 @@ import IR.Flat.BuildCode;
 import IR.State;
 import IR.TypeUtil;
 import Analysis.TaskStateAnalysis.TaskAnalysis;
+import Analysis.TaskStateAnalysis.TaskGraph;
 import Analysis.CallGraph.CallGraph;
 import Analysis.TaskStateAnalysis.TagAnalysis;
 
@@ -111,6 +112,8 @@ public class Main {
          TagAnalysis taganalysis=new TagAnalysis(state, callgraph);
          TaskAnalysis ta=new TaskAnalysis(state, taganalysis);
          ta.taskAnalysis();
+         TaskGraph tg=new TaskGraph(state, ta);
+         tg.createDOTfiles();
       }
       
       

diff --git a/Robust/src/Makefile b/Robust/src/Makefile
index 5d5355f85b612b8d2144fd09226331a01c9ec8af..bf77e642934f5c62f67ad6cd23dd42c67ffbee27 100644 (file)
--- a/Robust/src/Makefile
+++ b/Robust/src/Makefile
@@ -52,6 +52,7 @@ Analysis/TaskStateAnalysis/TagAnalysis.class                          \
 Analysis/TaskStateAnalysis/TagBinding.class                            \
 Analysis/TaskStateAnalysis/TaskAnalysis.class                          \
 Analysis/TaskStateAnalysis/TaskNode.class                              \
+Analysis/TaskStateAnalysis/TaskGraph.class                             \
 Analysis/CallGraph/CallGraph.class Util/Edge.class                     \
 Util/GraphNode.class Util/Relation.class