helpful progress reporting

[IRC.git] / Robust / src / IR / ClassDescriptor.java

diff --git a/Robust/src/IR/ClassDescriptor.java b/Robust/src/IR/ClassDescriptor.java
index 353ab00f4da5dd9cb6851163957fd16ede24e733..e38a12f6bba121151b9ca3365aa2d362a57b1d42 100644 (file)
--- a/Robust/src/IR/ClassDescriptor.java
+++ b/Robust/src/IR/ClassDescriptor.java
@@ -1,68 +1,142 @@
 package IR;
 import java.util.*;
 import IR.Tree.*;
-import IR.FieldDescriptor;
-import IR.MethodDescriptor;
-import IR.NameDescriptor;
-
-public class ClassDescriptor {
-    public ClassDescriptor() {
-       classname=null;
-       superclass=null;
-       fields=new Vector();
-       methods=new Vector();
-    }
-    String classname;
-    NameDescriptor superclass;
-    Modifiers modifiers;
-    Vector fields;
-    Vector methods;
-    
-    public Iterator getMethods() {
-       return methods.iterator();
-    }
-    
-    public String printTree(State state) {
-       int indent;
-       String st=modifiers.toString()+"class "+classname;
-       if (superclass!=null) 
-           st+="extends "+superclass.toString();
-       st+=" {\n";
-       indent=TreeNode.INDENT;
-       for(int i=0;i<fields.size();i++) {
-           FieldDescriptor fd=(FieldDescriptor)fields.get(i);
-           st+=TreeNode.printSpace(indent)+fd.toString()+"\n";
-       }
-       if (fields.size()>0)
-           st+="\n";
-
-       for(int i=0;i<methods.size();i++) {
-           MethodDescriptor md=(MethodDescriptor)methods.get(i);
-           st+=TreeNode.printSpace(indent)+md.toString()+" ";
-           BlockNode bn=state.getMethodBody(md);
-           st+=bn.printNode(indent)+"\n\n";
-       }
-       st+="}\n";
-       return st;
-    }
 
-    public void addField(FieldDescriptor fd) {
-       fields.add(fd);
-    }
+public class ClassDescriptor extends Descriptor {
+  private static int UIDCount=0;
+  private final int classid;
+  String superclass;
+  ClassDescriptor superdesc;
+  boolean hasFlags=false;
+  String packagename;
 
-    public void addMethod(MethodDescriptor md) {
-       methods.add(md);
-    }
-  
-    public void setModifiers(Modifiers modifiers) {
-       this.modifiers=modifiers;
+  Modifiers modifiers;
+
+  SymbolTable fields;
+  SymbolTable flags;
+  SymbolTable methods;
+
+  public ClassDescriptor(String classname) {
+    this("", classname);
+  }
+
+  public ClassDescriptor(String packagename, String classname) {
+    super(classname);
+    superclass=null;
+    flags=new SymbolTable();
+    fields=new SymbolTable();
+    methods=new SymbolTable();
+    classid=UIDCount++;
+    this.packagename=packagename;
+  }
+
+  public int getId() {
+    return classid;
+  }
+
+  public Iterator getMethods() {
+    return methods.getDescriptorsIterator();
+  }
+
+  public Iterator getFields() {
+    return fields.getDescriptorsIterator();
+  }
+
+  public Iterator getFlags() {
+    return flags.getDescriptorsIterator();
+  }
+
+  public SymbolTable getFieldTable() {
+    return fields;
+  }
+
+  public SymbolTable getFlagTable() {
+    return flags;
+  }
+
+  public SymbolTable getMethodTable() {
+    return methods;
+  }
+
+  public String getSafeDescriptor() {
+    return "L"+safename.replace('.','/');
+  }
+
+  public String printTree(State state) {
+    int indent;
+    String st=modifiers.toString()+"class "+getSymbol();
+    if (superclass!=null)
+      st+="extends "+superclass.toString();
+    st+=" {\n";
+    indent=TreeNode.INDENT;
+    boolean printcr=false;
+
+    for(Iterator it=getFlags(); it.hasNext();) {
+      FlagDescriptor fd=(FlagDescriptor)it.next();
+      st+=TreeNode.printSpace(indent)+fd.toString()+"\n";
+      printcr=true;
     }
+    if (printcr)
+      st+="\n";
 
-    public void setName(String name) {
-       classname=name;
+    printcr=false;
+
+    for(Iterator it=getFields(); it.hasNext();) {
+      FieldDescriptor fd=(FieldDescriptor)it.next();
+      st+=TreeNode.printSpace(indent)+fd.toString()+"\n";
+      printcr=true;
     }
+    if (printcr)
+      st+="\n";
 
-    public void setSuper(NameDescriptor superclass) {
-       this.superclass=superclass;
+    for(Iterator it=getMethods(); it.hasNext();) {
+      MethodDescriptor md=(MethodDescriptor)it.next();
+      st+=TreeNode.printSpace(indent)+md.toString()+" ";
+      BlockNode bn=state.getMethodBody(md);
+      st+=bn.printNode(indent)+"\n\n";
     }
+    st+="}\n";
+    return st;
+  }
+
+  public void addFlag(FlagDescriptor fd) {
+    if (flags.contains(fd.getSymbol()))
+      throw new Error(fd.getSymbol()+" already defined");
+    hasFlags=true;
+    flags.add(fd);
+  }
+
+  public boolean hasFlags() {
+    return hasFlags||getSuperDesc()!=null&&getSuperDesc().hasFlags();
+  }
+
+  public void addField(FieldDescriptor fd) {
+    if (fields.contains(fd.getSymbol()))
+      throw new Error(fd.getSymbol()+" already defined");
+    fields.add(fd);
+  }
+
+  public void addMethod(MethodDescriptor md) {
+    methods.add(md);
+  }
+
+  public void setModifiers(Modifiers modifiers) {
+    this.modifiers=modifiers;
+  }
+
+  public void setSuper(String superclass) {
+    this.superclass=superclass;
+  }
+
+  public ClassDescriptor getSuperDesc() {
+    return superdesc;
+  }
+
+  public void setSuper(ClassDescriptor scd) {
+    this.superdesc=scd;
+  }
+
+  public String getSuper() {
+    return superclass;
+  }
 }