Robust/src/IR/MethodDescriptor.java

   1 package IR;
   2 import IR.Tree.Modifiers;
   3 import IR.Tree.ExpressionNode;
   4 import java.util.Vector;
   5
   6 /**
   7  * Descriptor
   8  *
   9  * represents a symbol in the language (var name, function name, etc).
  10  */
  11
  12 public class MethodDescriptor extends Descriptor {
  13
  14     protected Modifiers modifier;
  15     protected TypeDescriptor returntype;
  16     protected String identifier;
  17     protected Vector params;
  18     protected SymbolTable paramtable;
  19     protected ClassDescriptor cd;
  20     protected VarDescriptor thisvd;
  21     protected boolean isglobal;
  22
  23     public MethodDescriptor(Modifiers m, TypeDescriptor rt, String identifier) {
  24         super(identifier);
  25         this.modifier=m;
  26         this.returntype=rt;
  27         this.identifier=identifier;
  28         this.safename = "___" + name + "___";
  29         this.uniqueid=count++;
  30         params=new Vector();
  31         paramtable=new SymbolTable();
  32         thisvd=null;
  33     }
  34
  35     public Modifiers getModifiers() {
  36         return modifier;
  37     }
  38
  39     public boolean matches(MethodDescriptor md) {
  40         /* Check the name */
  41         if (!identifier.equals(md.identifier))
  42             return false;
  43         if (numParameters()!=md.numParameters())
  44             return false;
  45         for(int i=0;i<numParameters();i++) {
  46             Descriptor d1=getParameter(i);
  47             Descriptor d2=md.getParameter(i);
  48             TypeDescriptor td1=(d1 instanceof TagVarDescriptor)?((TagVarDescriptor)d1).getType():((VarDescriptor)d1).getType();
  49             TypeDescriptor td2=(d2 instanceof TagVarDescriptor)?((TagVarDescriptor)d2).getType():((VarDescriptor)d2).getType();
  50             if (!td1.equals(td2))
  51                 return false;
  52         }
  53         return true;
  54     }
  55
  56     public MethodDescriptor(Modifiers m, String identifier) {
  57         this(m, identifier, false);
  58     }
  59
  60     public MethodDescriptor(Modifiers m, String identifier, boolean isglobal) {
  61         super(identifier);
  62         this.isglobal=isglobal;
  63         this.modifier=m;
  64         this.returntype=null;
  65         this.identifier=identifier;
  66         this.safename = "___" + name + "___";
  67         this.uniqueid=count++;
  68         params=new Vector();
  69         paramtable=new SymbolTable();
  70         thisvd=null;
  71     }
  72
  73
  74     public boolean isGlobal() {
  75         return isglobal;
  76     }
  77
  78     public void setThis(VarDescriptor vd) {
  79         thisvd=vd;
  80         paramtable.add(vd);
  81     }
  82
  83     public VarDescriptor getThis() {
  84         return thisvd;
  85     }
  86
  87     public String getSafeMethodDescriptor() {
  88         String st="";
  89         for(int i=0;i<numParameters();i++) {
  90             st+=getParamType(i).getSafeDescriptor();
  91             if ((i+1)<numParameters())
  92                 st+="_";
  93         }
  94         return st;
  95     }
  96
  97     public boolean isStatic() {
  98         return modifier.isStatic();
  99     }
 100
 101     public boolean isConstructor() {
 102         return (returntype==null);
 103     }
 104
 105     public TypeDescriptor getReturnType() {
 106         return returntype;
 107     }
 108
 109     public void setClassDesc(ClassDescriptor cd) {
 110         this.cd=cd;
 111     }
 112
 113     public ClassDescriptor getClassDesc() {
 114         return cd;
 115     }
 116
 117     public SymbolTable getParameterTable() {
 118         return paramtable;
 119     }
 120
 121     public void addParameter(TypeDescriptor type, String paramname) {
 122         if (paramname.equals("this"))
 123             throw new Error("Can't have parameter named this");
 124         VarDescriptor vd=new VarDescriptor(type, paramname);
 125
 126         params.add(vd);
 127         if (paramtable.getFromSameScope(paramname)!=null) {
 128             throw new Error("Parameter "+paramname+" already defined");
 129         }
 130         paramtable.add(vd);
 131     }
 132
 133     public void addTagParameter(TypeDescriptor type, String paramname) {
 134         if (paramname.equals("this"))
 135             throw new Error("Can't have parameter named this");
 136         TagVarDescriptor vd=new TagVarDescriptor(null, paramname);
 137
 138         params.add(vd);
 139         if (paramtable.getFromSameScope(paramname)!=null) {
 140             throw new Error("Parameter "+paramname+" already defined");
 141         }
 142         paramtable.add(vd);
 143     }
 144
 145     public int numParameters() {
 146         return params.size();
 147     }
 148
 149     public Descriptor getParameter(int i) {
 150         return (Descriptor) params.get(i);
 151     }
 152
 153     public String getParamName(int i) {
 154         return ((Descriptor)params.get(i)).getSymbol();
 155     }
 156
 157     public TypeDescriptor getParamType(int i) {
 158         Descriptor d=(Descriptor)params.get(i);
 159         if (d instanceof VarDescriptor)
 160             return ((VarDescriptor)params.get(i)).getType();
 161         else if (d instanceof TagVarDescriptor)
 162             return new TypeDescriptor(TypeDescriptor.TAG);
 163         else throw new Error();
 164     }
 165
 166     public String toString() {
 167         String st="";
 168         String type="";
 169         if (cd!=null)
 170             type=cd+".";
 171         if (returntype!=null)
 172             st=modifier.toString()+returntype.toString()+" "+type+identifier+"(";
 173         else
 174             st=modifier.toString()+" "+type+identifier+"(";
 175         for(int i=0;i<params.size();i++) {
 176             st+=getParamType(i)+" "+getParamName(i);
 177             if ((i+1)!=params.size())
 178                 st+=", ";
 179         }
 180         st+=")";
 181         return st;
 182     }
 183 }