Robust/src/IR/ClassDescriptor.java

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