Instanceof checks for jim

diff --git a/Robust/src/IR/Flat/BuildCode.java b/Robust/src/IR/Flat/BuildCode.java
index 7fee5babd76d777bce40d92e531695fc08bb7441..5110b2be6c77bfdbf8cb817b7d51f1858d6e458c 100644 (file)
--- a/Robust/src/IR/Flat/BuildCode.java
+++ b/Robust/src/IR/Flat/BuildCode.java
@@ -193,6 +193,7 @@ public class BuildCode {
     outstructs.close();
   }
 
+
   /* This code just generates the main C method for java programs.
    * The main C method packs up the arguments into a string array
    * and passes it to the java main method. */
@@ -349,6 +350,7 @@ public class BuildCode {
     //Store the sizes of classes & array elements
     generateSizeArray(outmethod);
 
+
     //Store table of supertypes
     generateSuperTypeTable(outmethod);
 
@@ -735,7 +737,6 @@ public class BuildCode {
       }
   }
 
-
   /** Generate array that contains the sizes of class objects.  The
    * object allocation functions in the runtime use this
    * information. */
@@ -792,6 +793,85 @@ public class BuildCode {
     }
 
     outclassdefs.println("};");
+
+    ClassDescriptor objectclass=typeutil.getClass(TypeUtil.ObjectClass);    
+    needcomma=false;
+    outclassdefs.print("int typearray[]={");
+    for(int i=0;i<state.numClasses();i++) {
+      ClassDescriptor cd=cdarray[i];
+      ClassDescriptor supercd=cd.getSuperDesc();
+      if (needcomma)
+       outclassdefs.print(", ");
+      if (supercd==null)
+       outclassdefs.print("-1");
+      else
+       outclassdefs.print(supercd.getId());
+      needcomma=true;
+    }
+
+    for(int i=0;i<state.numArrays();i++) {
+      TypeDescriptor arraytd=arraytable[i];
+      ClassDescriptor arraycd=arraytd.getClassDesc();
+      if (arraycd==null) {
+       if (needcomma)
+         outclassdefs.print(", ");
+       outclassdefs.print(objectclass.getId());
+       needcomma=true;
+       continue;
+      }
+      ClassDescriptor cd=arraycd.getSuperDesc();
+      int type=-1;
+      while(cd!=null) {
+       TypeDescriptor supertd=new TypeDescriptor(cd);
+       supertd.setArrayCount(arraytd.getArrayCount());
+       type=state.getArrayNumber(supertd);
+       if (type!=-1) {
+         type+=state.numClasses();
+         break;
+       }
+       cd=cd.getSuperDesc();
+      }
+      if (needcomma)
+       outclassdefs.print(", ");
+      outclassdefs.print(type);
+      needcomma=true;
+    }
+
+    outclassdefs.println("};");    
+
+    needcomma=false;
+
+
+    outclassdefs.print("int typearray2[]={");
+    for(int i=0;i<state.numArrays();i++) {
+      TypeDescriptor arraytd=arraytable[i];
+      ClassDescriptor arraycd=arraytd.getClassDesc();
+      if (arraycd==null) {
+       if (needcomma)
+         outclassdefs.print(", ");
+       outclassdefs.print("-1");
+       needcomma=true;
+       continue;
+      }
+      ClassDescriptor cd=arraycd.getSuperDesc();
+      int level=arraytd.getArrayCount()-1;
+      int type=-1;
+      for(;level>0;level--) {
+       TypeDescriptor supertd=new TypeDescriptor(objectclass);
+       supertd.setArrayCount(level);
+       type=state.getArrayNumber(supertd);
+       if (type!=-1) {
+         type+=state.numClasses();
+         break;
+       }
+      }
+      if (needcomma)
+       outclassdefs.print(", ");
+      outclassdefs.print(type);
+      needcomma=true;
+    }
+
+    outclassdefs.println("};");
   }
 
   /** Constructs params and temp objects for each method or task.
@@ -1440,6 +1520,10 @@ public class BuildCode {
       generateFlatAtomicExitNode(fm, lb, (FlatAtomicExitNode) fn, output);
       return;
 
+    case FKind.FlatInstanceOfNode:
+      generateFlatInstanceOfNode(fm, lb, (FlatInstanceOfNode)fn, output);
+      return;
+
     case FKind.FlatSESEEnterNode:
       generateFlatSESEEnterNode(fm, lb, (FlatSESEEnterNode) fn, output);
       return;
@@ -1721,6 +1805,20 @@ public class BuildCode {
     }
   }
 
+  public void generateFlatInstanceOfNode(FlatMethod fm,  LocalityBinding lb, FlatInstanceOfNode fion, PrintWriter output) {
+    int type;
+    if (fion.getType().isArray()) {
+      type=state.getArrayNumber(fion.getType())+state.numClasses();
+    } else {
+      type=fion.getType().getClassDesc().getId();
+    }
+    
+    if (fion.getType().getSymbol().equals(TypeUtil.ObjectClass))
+      output.println(generateTemp(fm, fion.getDst(), lb)+"=1;");
+    else
+      output.println(generateTemp(fm, fion.getDst(), lb)+"=instanceof("+generateTemp(fm,fion.getSrc(),lb)+","+type+");");
+  }
+
   public void generateFlatAtomicEnterNode(FlatMethod fm,  LocalityBinding lb, FlatAtomicEnterNode faen, PrintWriter output) {
     /* Check to see if we need to generate code for this atomic */
     if (locality.getAtomic(lb).get(faen.getPrev(0)).intValue()>0)

diff --git a/Robust/src/IR/Flat/BuildFlat.java b/Robust/src/IR/Flat/BuildFlat.java
index 0b0fb9228b17e3382d65855fedd7a6d4c25756fe..f964dd123638976c7d4ccd8352c9496f80acee0b 100644 (file)
--- a/Robust/src/IR/Flat/BuildFlat.java
+++ b/Robust/src/IR/Flat/BuildFlat.java
@@ -789,6 +789,9 @@ public class BuildFlat {
 
     case Kind.TertiaryNode:
       return flattenTertiaryNode((TertiaryNode)en,out_temp);
+
+    case Kind.InstanceOfNode:
+      return flattenInstanceOfNode((InstanceOfNode)en,out_temp);
     }
     throw new Error();
   }
@@ -1079,6 +1082,14 @@ public class BuildFlat {
       return new NodePair(fn,null);
   }
 
+  private NodePair flattenInstanceOfNode(InstanceOfNode tn, TempDescriptor out_temp) {
+    TempDescriptor expr_temp=TempDescriptor.tempFactory("expr",tn.getExpr().getType());
+    NodePair cond=flattenExpressionNode(tn.getExpr(), expr_temp);
+    FlatInstanceOfNode fion=new FlatInstanceOfNode(tn.getExprType(), expr_temp, out_temp);
+    cond.getEnd().addNext(fion);
+    return new NodePair(cond.getBegin(),fion);
+  }
+
   private NodePair flattenTertiaryNode(TertiaryNode tn, TempDescriptor out_temp) {
     TempDescriptor cond_temp=TempDescriptor.tempFactory("tert_cond",new TypeDescriptor(TypeDescriptor.BOOLEAN));
     TempDescriptor true_temp=TempDescriptor.tempFactory("tert_true",tn.getTrueExpr().getType());

diff --git a/Robust/src/IR/Flat/FKind.java b/Robust/src/IR/Flat/FKind.java
index 4108296a922ec4d222706626bc9c0cf255e898a0..467337a53abee2901de5ebd5bdbca34451802b0a 100644 (file)
--- a/Robust/src/IR/Flat/FKind.java
+++ b/Robust/src/IR/Flat/FKind.java
@@ -25,4 +25,5 @@ public class FKind {
   public static final int FlatOffsetNode=22;
   public static final int FlatSESEEnterNode=23;
   public static final int FlatSESEExitNode=24;
+  public static final int FlatInstanceOfNode=25;
 }

diff --git a/Robust/src/IR/State.java b/Robust/src/IR/State.java
index 36ed57ba2bc559e04e92a3fc5a57b8cc79d31000..e02d09d9ee8953e17c219319cdbcf8c894b2a67f 100644 (file)
--- a/Robust/src/IR/State.java
+++ b/Robust/src/IR/State.java
@@ -121,7 +121,7 @@ public class State {
   public int getArrayNumber(TypeDescriptor td) {
     if (arraytonumber.containsKey(td))
       return ((Integer)arraytonumber.get(td)).intValue();
-    else throw new Error("Could not find array type:" + td.toPrettyString());
+    else return -1;
   }
 
   public int numArrays() {

diff --git a/Robust/src/IR/Tree/BuildIR.java b/Robust/src/IR/Tree/BuildIR.java
index deb48958b54ee370040eea360b02bdb385a9fabe..12149c3e3ff47c7e9815533a163ca47f5d459e3e 100644 (file)
--- a/Robust/src/IR/Tree/BuildIR.java
+++ b/Robust/src/IR/Tree/BuildIR.java
@@ -484,6 +484,10 @@ public class BuildIR {
       return new TertiaryNode(parseExpression(pn.getChild("cond").getFirstChild()),
                              parseExpression(pn.getChild("trueexpr").getFirstChild()),
                              parseExpression(pn.getChild("falseexpr").getFirstChild()) );
+    } else if (isNode(pn, "instanceof")) {
+      ExpressionNode exp=parseExpression(pn.getChild("exp").getFirstChild());
+      TypeDescriptor t=parseTypeDescriptor(pn);
+      return new InstanceOfNode(exp,t);
     } else {
       System.out.println("---------------------");
       System.out.println(pn.PPrint(3,true));

diff --git a/Robust/src/IR/Tree/Kind.java b/Robust/src/IR/Tree/Kind.java
index 7f26f7ffc3c47a95788e3ada54af8ec7c077faaa..7b93997a96c25e9ff73d016c624fa7b0e79731d7 100644 (file)
--- a/Robust/src/IR/Tree/Kind.java
+++ b/Robust/src/IR/Tree/Kind.java
@@ -26,4 +26,5 @@ public class Kind {
   public final static int SESENode=23;
   public final static int ContinueBreakNode=24;
   public final static int TertiaryNode=25;
+  public final static int InstanceOfNode=26;
 }

diff --git a/Robust/src/IR/Tree/SemanticCheck.java b/Robust/src/IR/Tree/SemanticCheck.java
index dac024e0bdaf8dca1b64b92ce36fc75eaf002df0..0acbbe66a0e1c09adf136d315d9283eab500890c 100644 (file)
--- a/Robust/src/IR/Tree/SemanticCheck.java
+++ b/Robust/src/IR/Tree/SemanticCheck.java
@@ -399,6 +399,10 @@ public class SemanticCheck {
     case Kind.TertiaryNode:
       checkTertiaryNode(md, nametable, (TertiaryNode)en, td);
       return;
+      
+    case Kind.InstanceOfNode:
+      checkInstanceOfNode(md, nametable, (InstanceOfNode) en, td);
+      return;
     }
     throw new Error();
   }
@@ -557,6 +561,14 @@ public class SemanticCheck {
     checkExpressionNode(md, nametable, tn.getFalseExpr(), td );
   }
 
+  void checkInstanceOfNode(Descriptor md, SymbolTable nametable, InstanceOfNode tn, TypeDescriptor td) {
+    if (!td.isBoolean())
+      throw new Error("Expecting type "+td+"for instanceof expression");
+    
+    checkTypeDescriptor(tn.getExprType());
+    checkExpressionNode(md, nametable, tn.getExpr(), null);
+  }
+
 
   void checkAssignmentNode(Descriptor md, SymbolTable nametable, AssignmentNode an, TypeDescriptor td) {
     boolean postinc=true;

diff --git a/Robust/src/IR/TypeDescriptor.java b/Robust/src/IR/TypeDescriptor.java
index ddef484956388b1e3b42d0ebdfecf24a2487bc70..014f584f4ff516c22f0fdc2abad28d81fc2795e2 100644 (file)
--- a/Robust/src/IR/TypeDescriptor.java
+++ b/Robust/src/IR/TypeDescriptor.java
@@ -74,6 +74,13 @@ public class TypeDescriptor extends Descriptor {
     return arraycount;
   }
 
+  /* Only use this method if you really know what you are doing.  It
+   * doesn't have the effect you might expect. */
+
+  public void setArrayCount(int a) {
+    arraycount=a;
+  }
+
   public TypeDescriptor dereference() {
     TypeDescriptor td=new TypeDescriptor(getSymbol());
     if (arraycount==0)

diff --git a/Robust/src/Parse/java14.cup b/Robust/src/Parse/java14.cup
index a1d07a811ccac7a27951eaa23b50718047f2eef0..6f6c2f3108e0a563470f57a1f8ce7209bafcfb1d 100644 (file)
--- a/Robust/src/Parse/java14.cup
+++ b/Robust/src/Parse/java14.cup
@@ -1781,7 +1781,12 @@ relational_expression ::=
                pn.addChild(exp2);
                RESULT=pn;
        :}
-//     |       relational_expression INSTANCEOF reference_type
+       |       relational_expression:exp INSTANCEOF reference_type:type {: 
+               ParseNode pn=new ParseNode("instanceof");
+               pn.addChild("exp").addChild(exp);
+               pn.addChild(type);
+               RESULT=pn;
+       :}
        ;
 
 equality_expression ::=