add more comments

[IRC.git] / Robust / src / IR / State.java

diff --git a/Robust/src/IR/State.java b/Robust/src/IR/State.java
index b8b43463c92a8b50a1a78d6ca76451ed5060169d..9df0cc3235d9d2067de8914edc0b1f491e09839a 100644 (file)
--- a/Robust/src/IR/State.java
+++ b/Robust/src/IR/State.java
@@ -5,39 +5,90 @@ import IR.*;
 import java.util.*;
 
 public class State {
-    public String main;
-
     public State() {
        this.classes=new SymbolTable();
+       this.tasks=new SymbolTable();
        this.treemethodmap=new Hashtable();
        this.flatmethodmap=new Hashtable();
        this.parsetrees=new HashSet();
        this.arraytypes=new HashSet();
        this.arraytonumber=new Hashtable();
+       this.tagmap=new Hashtable();
+       this.analysisresult=new Hashtable();
+       this.optionaltaskdescriptors=new Hashtable();
     }
 
     public void addParseNode(ParseNode parsetree) {
        parsetrees.add(parsetree);
     }
 
+    public void storeAnalysisResult(Hashtable result){
+       analysisresult = result;
+    }
+    
+    public void storeOptionalTaskDescriptors(Hashtable optionaltaskdescriptors){
+       this.optionaltaskdescriptors=optionaltaskdescriptors;
+    }
+
+    public Hashtable getAnalysisResult(){
+       return analysisresult;
+    }
+    
+    public Hashtable getOptionalTaskDescriptors(){
+       return optionaltaskdescriptors;
+    }
+
+    /** Boolean flag which indicates whether compiler is compiling a task-based
+     * program. */
+    public boolean WEBINTERFACE=false;
+    public boolean TASK=false;
+    public boolean DSM=false;
+    public boolean TASKSTATE=false;
+    public boolean OPTIONAL=false;
+    public boolean THREAD=false;
+    public boolean CONSCHECK=false;
+    public boolean INSTRUCTIONFAILURE=false;
+    public String structfile;
+    public String main;
+
     public SymbolTable classes;
+    public SymbolTable tasks;
     public Set parsetrees;
     public Hashtable treemethodmap;
     public Hashtable flatmethodmap;
     private HashSet arraytypes;
     public Hashtable arraytonumber;
     private int numclasses=0;
+    private int numtasks=0;
     private int arraycount=0;
 
+
+    private Hashtable analysisresult;
+    private Hashtable optionaltaskdescriptors;
+
+    private Hashtable tagmap;
+    private int numtags=0;
+
     public void addArrayType(TypeDescriptor td) {
-       arraytypes.add(td);
-       arraytonumber.put(td,new Integer(arraycount++));
+       if (!arraytypes.contains(td)) {
+           arraytypes.add(td);
+           arraytonumber.put(td,new Integer(arraycount++));
+       }
     }
 
     public Iterator getArrayIterator() {
        return arraytypes.iterator();
     }
 
+    public int getTagId(TagDescriptor tag) {
+       if (tagmap.containsKey(tag)) {
+           return ((Integer) tagmap.get(tag)).intValue();
+       } else {
+           tagmap.put(tag, new Integer(numtags));
+           return numtags++;
+       }
+    }
+
     public int getArrayNumber(TypeDescriptor td) {
        return ((Integer)arraytonumber.get(td)).intValue();
     }
@@ -71,19 +122,50 @@ public class State {
        return (BlockNode)treemethodmap.get(md);
     }
 
+    public BlockNode getMethodBody(TaskDescriptor td) {
+       return (BlockNode)treemethodmap.get(td);
+    }
+
     public SymbolTable getClassSymbolTable() {
        return classes;
     }
 
+    public SymbolTable getTaskSymbolTable() {
+       return tasks;
+    }
+
+    /** Returns Flat IR representation of MethodDescriptor md. */
+
     public FlatMethod getMethodFlat(MethodDescriptor md) {
        return (FlatMethod)flatmethodmap.get(md);
     }
 
+    /** Returns Flat IR representation of TaskDescriptor td. */
+
+    public FlatMethod getMethodFlat(TaskDescriptor td) {
+       return (FlatMethod)flatmethodmap.get(td);
+    }
+
     public void addTreeCode(MethodDescriptor md, BlockNode bn) {
        treemethodmap.put(md,bn);
     }
 
+    public void addTreeCode(TaskDescriptor td, BlockNode bn) {
+       treemethodmap.put(td,bn);
+    }
+
     public void addFlatCode(MethodDescriptor md, FlatMethod bn) {
        flatmethodmap.put(md,bn);
     }
+
+    public void addFlatCode(TaskDescriptor td, FlatMethod bn) {
+       flatmethodmap.put(td,bn);
+    }
+
+    public void addTask(TaskDescriptor td) {
+       if (tasks.contains(td.getSymbol()))
+           throw new Error("Task "+td.getSymbol()+" defined twice");
+       tasks.add(td);
+       numtasks++;
+    }
 }