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