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 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 SymbolTable globals;
- public ParseNode parsetree;
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++;
+ }
}