Programming Languages Research Group: Git - IRC.git/blob

   1 package IR;
   2 import java.util.*;
   3
   4 public class TypeUtil {
   5     public static final String StringClass="String";
   6     public static final String ObjectClass="Object";
   7     public static final String StartupClass="StartupObject";
   8     public static final String TagClass="TagDescriptor";
   9     public static final String ThreadClass="Thread";
  10     State state;
  11     Hashtable supertable;
  12     Hashtable subclasstable;
  13
  14     public TypeUtil(State state) {
  15         this.state=state;
  16         createTables();
  17     }
  18
  19     public ClassDescriptor getClass(String classname) {
  20         ClassDescriptor cd=(ClassDescriptor)state.getClassSymbolTable().get(classname);
  21         return cd;
  22     }
  23
  24     private void createTables() {
  25         supertable=new Hashtable();
  26
  27         Iterator classit=state.getClassSymbolTable().getDescriptorsIterator();
  28         while(classit.hasNext()) {
  29             ClassDescriptor cd=(ClassDescriptor)classit.next();
  30             String superc=cd.getSuper();
  31             if (superc!=null) {
  32                 ClassDescriptor cd_super=getClass(superc);
  33                 if (cd_super==null) {
  34                     throw new Error("Couldn't find class:"+superc);
  35                 }
  36                 supertable.put(cd,cd_super);
  37             }
  38         }
  39     }
  40
  41     public ClassDescriptor getMainClass() {
  42         return getClass(state.main);
  43     }
  44
  45     public MethodDescriptor getRun() {
  46         ClassDescriptor cd=getClass(TypeUtil.ThreadClass);
  47         for(Iterator methodit=cd.getMethodTable().getSet("run").iterator();methodit.hasNext();) {
  48             MethodDescriptor md=(MethodDescriptor) methodit.next();
  49             if (md.numParameters()!=0||md.getModifiers().isStatic())
  50                 continue;
  51             return md;
  52         }
  53         throw new Error("Can't find Thread.run");
  54     }
  55
  56     public MethodDescriptor getMain() {
  57         ClassDescriptor cd=getMainClass();
  58         Set mainset=cd.getMethodTable().getSet("main");
  59         for(Iterator mainit=mainset.iterator();mainit.hasNext();) {
  60             MethodDescriptor md=(MethodDescriptor)mainit.next();
  61             if (md.numParameters()!=1)
  62                 continue;
  63             Descriptor pd=md.getParameter(0);
  64             TypeDescriptor tpd=(pd instanceof TagVarDescriptor)?((TagVarDescriptor)pd).getType():((VarDescriptor)pd)
  65                 .getType();
  66             if (tpd.getArrayCount()!=1)
  67                 continue;
  68             if (!tpd.getSymbol().equals("String"))
  69                 continue;
  70
  71             if (!md.getModifiers().isStatic())
  72                 throw new Error("Error: Non static main");
  73             return md;
  74         }
  75         throw new Error(cd+" has no main");
  76     }
  77
  78     /** Check to see if md1 is more specific than md2...  Informally
  79         if md2 could always be called given the arguments passed into
  80         md1 */
  81
  82     public boolean isMoreSpecific(MethodDescriptor md1, MethodDescriptor md2) {
  83         /* Checks if md1 is more specific than md2 */
  84         if (md1.numParameters()!=md2.numParameters())
  85             throw new Error();
  86         for(int i=0;i<md1.numParameters();i++) {
  87             if (!this.isSuperorType(md2.getParamType(i), md1.getParamType(i)))
  88                 return false;
  89         }
  90         if (!this.isSuperorType(md2.getReturnType(), md1.getReturnType()))
  91                 return false;
  92
  93         if (!this.isSuperorType(md2.getClassDesc(), md1.getClassDesc()))
  94                 return false;
  95
  96         return true;
  97     }
  98
  99     public MethodDescriptor getMethod(ClassDescriptor cd, String name, TypeDescriptor[] types) {
 100         Set methoddescriptorset=cd.getMethodTable().getSet(name);
 101         MethodDescriptor bestmd=null;
 102         NextMethod:
 103         for(Iterator methodit=methoddescriptorset.iterator();methodit.hasNext();) {
 104             MethodDescriptor currmd=(MethodDescriptor)methodit.next();
 105             /* Need correct number of parameters */
 106             if (types.length!=currmd.numParameters())
 107                 continue;
 108             for(int i=0;i<types.length;i++) {
 109                 if (!this.isSuperorType(currmd.getParamType(i),types[i]))
 110                     continue NextMethod;
 111             }
 112             /* Method okay so far */
 113             if (bestmd==null)
 114                 bestmd=currmd;
 115             else {
 116                 if (isMoreSpecific(currmd,bestmd)) {
 117                     bestmd=currmd;
 118                 } else if (!isMoreSpecific(bestmd, currmd))
 119                     throw new Error("No method is most specific");
 120
 121                 /* Is this more specific than bestmd */
 122             }
 123         }
 124         if (bestmd==null)
 125             throw new Error("Could find: "+name + " in "+cd);
 126
 127         return bestmd;
 128     }
 129
 130     public void createFullTable() {
 131         subclasstable=new Hashtable();
 132
 133         Iterator classit=state.getClassSymbolTable().getDescriptorsIterator();
 134         while(classit.hasNext()) {
 135             ClassDescriptor cd=(ClassDescriptor)classit.next();
 136             ClassDescriptor tmp=cd.getSuperDesc();
 137
 138             while(tmp!=null) {
 139                 if (!subclasstable.containsKey(tmp))
 140                     subclasstable.put(tmp,new HashSet());
 141                 HashSet hs=(HashSet)subclasstable.get(tmp);
 142                 hs.add(cd);
 143                 tmp=tmp.getSuperDesc();
 144             }
 145         }
 146     }
 147
 148     public Set getSubClasses(ClassDescriptor cd) {
 149         return (Set)subclasstable.get(cd);
 150     }
 151
 152     public ClassDescriptor getSuper(ClassDescriptor cd) {
 153         return (ClassDescriptor)supertable.get(cd);
 154     }
 155
 156     public boolean isCastable(TypeDescriptor original, TypeDescriptor casttype) {
 157         if (original.isChar()&&
 158             (casttype.isByte()||
 159              casttype.isShort()))
 160             return true;
 161
 162         if (casttype.isChar()&&
 163             (original.isByte()||
 164              original.isShort()||
 165              original.isInt()||
 166              original.isLong()||
 167              original.isFloat()||
 168              original.isDouble()))
 169             return true;
 170
 171         return false;
 172     }
 173
 174     public boolean isSuperorType(TypeDescriptor possiblesuper, TypeDescriptor cd2) {
 175         //Matching type are always okay
 176         if (possiblesuper.equals(cd2))
 177             return true;
 178
 179         if ((possiblesuper.isTag() && !cd2.isTag())||
 180             (!possiblesuper.isTag() && cd2.isTag()))
 181             return false;
 182
 183         //Handle arrays
 184         if (cd2.isArray()||possiblesuper.isArray()) {
 185             // Object is super class of all arrays
 186             if (possiblesuper.getSymbol().equals(ObjectClass)&&!possiblesuper.isArray())
 187                 return true;
 188
 189             // If we have the same dimensionality of arrays & both are classes, we can default to the normal test
 190             if (cd2.isClass()&&possiblesuper.isClass()
 191                 &&(possiblesuper.getArrayCount()==cd2.getArrayCount())&&
 192                 isSuperorType(possiblesuper.getClassDesc(), cd2.getClassDesc()))
 193                 return true;
 194
 195             // Object is superclass of all array classes
 196             if (possiblesuper.getSymbol().equals(ObjectClass)&&cd2.isClass()
 197                 &&(possiblesuper.getArrayCount()<cd2.getArrayCount()))
 198                 return true;
 199
 200             return false;
 201         }
 202
 203         if (possiblesuper.isClass()&&
 204              cd2.isClass())
 205             return isSuperorType(possiblesuper.getClassDesc(), cd2.getClassDesc());
 206         else if (possiblesuper.isClass()&&
 207                  cd2.isNull())
 208             return true;
 209         else if (possiblesuper.isNull())
 210             throw new Error(); //not sure when this case would occur
 211         else if (possiblesuper.isPrimitive()&&
 212                  cd2.isPrimitive()) {
 213             ///Primitive widenings from 5.1.2
 214             if (cd2.isByte()&&(possiblesuper.isByte()||possiblesuper.isShort()||
 215                                possiblesuper.isInt()||possiblesuper.isLong()||
 216                                possiblesuper.isFloat()||possiblesuper.isDouble()))
 217                 return true;
 218             if (cd2.isShort()&&(possiblesuper.isShort()||
 219                                 possiblesuper.isInt()||possiblesuper.isLong()||
 220                                 possiblesuper.isFloat()||possiblesuper.isDouble()))
 221                 return true;
 222             if (cd2.isChar()&&(possiblesuper.isChar()||
 223                                possiblesuper.isInt()||possiblesuper.isLong()||
 224                                possiblesuper.isFloat()||possiblesuper.isDouble()))
 225                 return true;
 226             if (cd2.isInt()&&(possiblesuper.isInt()||possiblesuper.isLong()||
 227                               possiblesuper.isFloat()||possiblesuper.isDouble()))
 228                 return true;
 229             if (cd2.isLong()&&(possiblesuper.isLong()||
 230                                possiblesuper.isFloat()||possiblesuper.isDouble()))
 231                 return true;
 232             if (cd2.isFloat()&&(possiblesuper.isFloat()||possiblesuper.isDouble()))
 233                 return true;
 234             if (cd2.isDouble()&&possiblesuper.isDouble())
 235
 236                 return true;
 237             if (cd2.isBoolean()&&possiblesuper.isBoolean())
 238                 return true;
 239
 240             return false;
 241         } else if (possiblesuper.isPrimitive()&&(!possiblesuper.isArray())&&
 242                    cd2.isPtr())
 243             return false;
 244         else if (cd2.isPrimitive()&&(!cd2.isArray())&&
 245                  possiblesuper.isPtr())
 246             return false;
 247         else
 248             throw new Error("Case not handled:"+possiblesuper+" "+cd2);
 249     }
 250
 251
 252     public boolean isSuperorType(ClassDescriptor possiblesuper, ClassDescriptor cd2) {
 253         if (possiblesuper==cd2)
 254             return true;
 255         else
 256             return isSuper(possiblesuper, cd2);
 257     }
 258
 259     private boolean isSuper(ClassDescriptor possiblesuper, ClassDescriptor cd2) {
 260         while(cd2!=null) {
 261             cd2=getSuper(cd2);
 262             if (cd2==possiblesuper)
 263                 return true;
 264         }
 265         return false;
 266     }
 267 }