Robust/src/IR/State.java

   1 package IR;
   2 import IR.Tree.*;
   3 import IR.Flat.*;
   4 import IR.*;
   5 import java.util.*;
   6 import Analysis.TaskStateAnalysis.*;
   7
   8 public class State {
   9     public State() {
  10         this.classes=new SymbolTable();
  11         this.tasks=new SymbolTable();
  12         this.treemethodmap=new Hashtable();
  13         this.flatmethodmap=new Hashtable();
  14         this.parsetrees=new HashSet();
  15         this.arraytypes=new HashSet();
  16         this.arraytonumber=new Hashtable();
  17         this.tagmap=new Hashtable();
  18     }
  19
  20     public void addParseNode(ParseNode parsetree) {
  21         parsetrees.add(parsetree);
  22     }
  23
  24     public void storeAnalysisResult(Hashtable<ClassDescriptor, Hashtable<FlagState, Set<OptionalTaskDescriptor>>> analysisresults) {
  25         this.analysisresults=analysisresults;
  26     }
  27
  28     public Hashtable<ClassDescriptor, Hashtable<FlagState, Set<OptionalTaskDescriptor>>> getAnalysisResult() {
  29         return analysisresults;
  30     }
  31
  32
  33     public void storeOptionalTaskDescriptors(Hashtable<ClassDescriptor, Hashtable<OptionalTaskDescriptor, OptionalTaskDescriptor>> optionaltaskdescriptors){
  34         this.optionaltaskdescriptors=optionaltaskdescriptors;
  35     }
  36
  37     public Hashtable<ClassDescriptor, Hashtable<OptionalTaskDescriptor, OptionalTaskDescriptor>> getOptionalTaskDescriptors(){
  38         return optionaltaskdescriptors;
  39     }
  40
  41     /** Boolean flag which indicates whether compiler is compiling a task-based
  42      * program. */
  43     public boolean WEBINTERFACE=false;
  44     public boolean TASK=false;
  45     public boolean DSM=false;
  46     public boolean PREFETCH=false;
  47     public boolean TASKSTATE=false;
  48     public boolean OPTIONAL=false;
  49     public boolean THREAD=false;
  50     public boolean CONSCHECK=false;
  51     public boolean INSTRUCTIONFAILURE=false;
  52     public String structfile;
  53     public String main;
  54
  55     public SymbolTable classes;
  56     public SymbolTable tasks;
  57     public Set parsetrees;
  58     public Hashtable treemethodmap;
  59     public Hashtable flatmethodmap;
  60     private HashSet arraytypes;
  61     public Hashtable arraytonumber;
  62     private int numclasses=0;
  63     private int numtasks=0;
  64     private int arraycount=0;
  65
  66
  67     private Hashtable<ClassDescriptor, Hashtable<OptionalTaskDescriptor, OptionalTaskDescriptor>> optionaltaskdescriptors;
  68     private Hashtable<ClassDescriptor, Hashtable<FlagState, Set<OptionalTaskDescriptor>>> analysisresults;
  69
  70     private Hashtable tagmap;
  71     private int numtags=0;
  72
  73     public void addArrayType(TypeDescriptor td) {
  74         if (!arraytypes.contains(td)) {
  75             arraytypes.add(td);
  76             arraytonumber.put(td,new Integer(arraycount++));
  77         }
  78     }
  79
  80     public Iterator getArrayIterator() {
  81         return arraytypes.iterator();
  82     }
  83
  84     public int getTagId(TagDescriptor tag) {
  85         if (tagmap.containsKey(tag)) {
  86             return ((Integer) tagmap.get(tag)).intValue();
  87         } else {
  88             tagmap.put(tag, new Integer(numtags));
  89             return numtags++;
  90         }
  91     }
  92
  93     public int getArrayNumber(TypeDescriptor td) {
  94         return ((Integer)arraytonumber.get(td)).intValue();
  95     }
  96
  97     public int numArrays() {
  98         return arraytypes.size();
  99     }
 100
 101     public static TypeDescriptor getTypeDescriptor(int t) {
 102         TypeDescriptor td=new TypeDescriptor(t);
 103         return td;
 104     }
 105
 106     public static TypeDescriptor getTypeDescriptor(NameDescriptor n) {
 107         TypeDescriptor td=new TypeDescriptor(n);
 108         return td;
 109     }
 110
 111     public void addClass(ClassDescriptor tdn) {
 112         if (classes.contains(tdn.getSymbol()))
 113             throw new Error("Class "+tdn.getSymbol()+" defined twice");
 114         classes.add(tdn);
 115         numclasses++;
 116     }
 117
 118     public int numClasses() {
 119         return numclasses;
 120     }
 121
 122     public BlockNode getMethodBody(MethodDescriptor md) {
 123         return (BlockNode)treemethodmap.get(md);
 124     }
 125
 126     public BlockNode getMethodBody(TaskDescriptor td) {
 127         return (BlockNode)treemethodmap.get(td);
 128     }
 129
 130     public SymbolTable getClassSymbolTable() {
 131         return classes;
 132     }
 133
 134     public SymbolTable getTaskSymbolTable() {
 135         return tasks;
 136     }
 137
 138     /** Returns Flat IR representation of MethodDescriptor md. */
 139
 140     public FlatMethod getMethodFlat(MethodDescriptor md) {
 141         return (FlatMethod)flatmethodmap.get(md);
 142     }
 143
 144     /** Returns Flat IR representation of TaskDescriptor td. */
 145
 146     public FlatMethod getMethodFlat(TaskDescriptor td) {
 147         return (FlatMethod)flatmethodmap.get(td);
 148     }
 149
 150     public void addTreeCode(MethodDescriptor md, BlockNode bn) {
 151         treemethodmap.put(md,bn);
 152     }
 153
 154     public void addTreeCode(TaskDescriptor td, BlockNode bn) {
 155         treemethodmap.put(td,bn);
 156     }
 157
 158     public void addFlatCode(MethodDescriptor md, FlatMethod bn) {
 159         flatmethodmap.put(md,bn);
 160     }
 161
 162     public void addFlatCode(TaskDescriptor td, FlatMethod bn) {
 163         flatmethodmap.put(td,bn);
 164     }
 165
 166     public void addTask(TaskDescriptor td) {
 167         if (tasks.contains(td.getSymbol()))
 168             throw new Error("Task "+td.getSymbol()+" defined twice");
 169         tasks.add(td);
 170         numtasks++;
 171     }
 172 }