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 cb6c22d5b7a5aff30181513bd2475f99d500e779..9df0cc3235d9d2067de8914edc0b1f491e09839a 100644 (file)
--- a/Robust/src/IR/State.java
+++ b/Robust/src/IR/State.java
@@ -1,12 +1,171 @@
 package IR;
 import IR.Tree.*;
+import IR.Flat.*;
+import IR.*;
+import java.util.*;
 
 public class State {
-    public State(ParseNode parsetree) {
-       globals=new SymbolTable();
-       this.parsetree=parsetree;
+    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 SymbolTable globals;
-    public ParseNode parsetree;
 
+    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) {
+       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();
+    }
+
+    public int numArrays() {
+       return arraytypes.size();
+    }
+
+    public static TypeDescriptor getTypeDescriptor(int t) {
+       TypeDescriptor td=new TypeDescriptor(t);
+       return td;
+    }
+
+    public static TypeDescriptor getTypeDescriptor(NameDescriptor n) {
+       TypeDescriptor td=new TypeDescriptor(n);
+       return td;
+    }
+
+    public void addClass(ClassDescriptor tdn) {
+       if (classes.contains(tdn.getSymbol()))
+           throw new Error("Class "+tdn.getSymbol()+" defined twice");
+       classes.add(tdn);
+       numclasses++;
+    }
+
+    public int numClasses() {
+       return numclasses;
+    }
+
+    public BlockNode getMethodBody(MethodDescriptor md) {
+       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++;
+    }
 }