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 }