Robust/src/IR/ClassDescriptor.java

   1 package IR;
   2 import java.util.*;
   3 import IR.Tree.*;
   4
   5 public class ClassDescriptor extends Descriptor {
   6   private static int UIDCount=1; // start from 1 instead of 0 for multicore gc
   7   private final int classid;
   8   String superclass;
   9   ClassDescriptor superdesc;
  10   boolean hasFlags=false;
  11   String packagename;
  12
  13   Modifiers modifiers;
  14
  15   SymbolTable fields;
  16   Vector fieldvec;
  17   SymbolTable flags;
  18   SymbolTable methods;
  19
  20   public ClassDescriptor(String classname) {
  21     this("", classname);
  22   }
  23
  24   public ClassDescriptor(String packagename, String classname) {
  25     super(classname);
  26     superclass=null;
  27     flags=new SymbolTable();
  28     fields=new SymbolTable();
  29     fieldvec=new Vector();
  30     methods=new SymbolTable();
  31     classid=UIDCount++;
  32     this.packagename=packagename;
  33   }
  34
  35   public int getId() {
  36     return classid;
  37   }
  38
  39   public Iterator getMethods() {
  40     return methods.getDescriptorsIterator();
  41   }
  42
  43   public Iterator getFields() {
  44     return fields.getDescriptorsIterator();
  45   }
  46
  47   public Iterator getFlags() {
  48     return flags.getDescriptorsIterator();
  49   }
  50
  51   public SymbolTable getFieldTable() {
  52     return fields;
  53   }
  54
  55   public Vector getFieldVec() {
  56     return fieldvec;
  57   }
  58
  59   public SymbolTable getFlagTable() {
  60     return flags;
  61   }
  62
  63   public SymbolTable getMethodTable() {
  64     return methods;
  65   }
  66
  67   public String getSafeDescriptor() {
  68     return "L"+safename.replace('.','/');
  69   }
  70
  71   public String printTree(State state) {
  72     int indent;
  73     String st=modifiers.toString()+"class "+getSymbol();
  74     if (superclass!=null)
  75       st+="extends "+superclass.toString();
  76     st+=" {\n";
  77     indent=TreeNode.INDENT;
  78     boolean printcr=false;
  79
  80     for(Iterator it=getFlags(); it.hasNext();) {
  81       FlagDescriptor fd=(FlagDescriptor)it.next();
  82       st+=TreeNode.printSpace(indent)+fd.toString()+"\n";
  83       printcr=true;
  84     }
  85     if (printcr)
  86       st+="\n";
  87
  88     printcr=false;
  89
  90     for(Iterator it=getFields(); it.hasNext();) {
  91       FieldDescriptor fd=(FieldDescriptor)it.next();
  92       st+=TreeNode.printSpace(indent)+fd.toString()+"\n";
  93       printcr=true;
  94     }
  95     if (printcr)
  96       st+="\n";
  97
  98     for(Iterator it=getMethods(); it.hasNext();) {
  99       MethodDescriptor md=(MethodDescriptor)it.next();
 100       st+=TreeNode.printSpace(indent)+md.toString()+" ";
 101       BlockNode bn=state.getMethodBody(md);
 102       st+=bn.printNode(indent)+"\n\n";
 103     }
 104     st+="}\n";
 105     return st;
 106   }
 107
 108   public void addFlag(FlagDescriptor fd) {
 109     if (flags.contains(fd.getSymbol()))
 110       throw new Error(fd.getSymbol()+" already defined");
 111     hasFlags=true;
 112     flags.add(fd);
 113   }
 114
 115   public boolean hasFlags() {
 116     return hasFlags||getSuperDesc()!=null&&getSuperDesc().hasFlags();
 117   }
 118
 119   public void addField(FieldDescriptor fd) {
 120     if (fields.contains(fd.getSymbol()))
 121       throw new Error(fd.getSymbol()+" already defined");
 122     fields.add(fd);
 123     fieldvec.add(fd);
 124   }
 125
 126   public void addMethod(MethodDescriptor md) {
 127     methods.add(md);
 128   }
 129
 130   public void setModifiers(Modifiers modifiers) {
 131     this.modifiers=modifiers;
 132   }
 133
 134   public void setSuper(String superclass) {
 135     this.superclass=superclass;
 136   }
 137
 138   public ClassDescriptor getSuperDesc() {
 139     return superdesc;
 140   }
 141
 142   public void setSuper(ClassDescriptor scd) {
 143     this.superdesc=scd;
 144   }
 145
 146   public String getSuper() {
 147     return superclass;
 148   }
 149 }