changes.

[IRC.git] / Robust / src / Analysis / SSJava / MethodAnnotationCheck.java

diff --git a/Robust/src/Analysis/SSJava/MethodAnnotationCheck.java b/Robust/src/Analysis/SSJava/MethodAnnotationCheck.java
index eba5f777d98ea6c336de8b2b78b27147e5c6b77d..9ed0123f3bf71c9e0e6358c146fb30ab3b321fb9 100644 (file)
--- a/Robust/src/Analysis/SSJava/MethodAnnotationCheck.java
+++ b/Robust/src/Analysis/SSJava/MethodAnnotationCheck.java
@@ -4,7 +4,9 @@ import java.util.HashSet;
 import java.util.Hashtable;
 import java.util.Iterator;
 import java.util.Set;
+import java.util.Vector;
 
+import IR.AnnotationDescriptor;
 import IR.ClassDescriptor;
 import IR.MethodDescriptor;
 import IR.Operation;
@@ -62,9 +64,10 @@ public class MethodAnnotationCheck {
       ClassDescriptor cd = (ClassDescriptor) obj;
       toanalyze.remove(cd);
 
-      if (!cd.isInterface()) {
+      if (!ssjava.isSSJavaUtil(cd) && !cd.isInterface()) {
         for (Iterator method_it = cd.getMethods(); method_it.hasNext();) {
           MethodDescriptor md = (MethodDescriptor) method_it.next();
+          checkTrustworthyMethodAnnotation(md);
           checkMethodBody(cd, md);
         }
       }
@@ -73,7 +76,9 @@ public class MethodAnnotationCheck {
 
     for (Iterator iterator = annotatedMDSet.iterator(); iterator.hasNext();) {
       MethodDescriptor md = (MethodDescriptor) iterator.next();
-      ssjava.addAnnotationRequire(md);
+      if (!ssjava.isTrustMethod(md)) {
+        ssjava.addAnnotationRequire(md);
+      }
     }
 
     Set<Pair> visited = new HashSet<Pair>();
@@ -92,19 +97,22 @@ public class MethodAnnotationCheck {
           if (!visited.contains(p)) {
             visited.add(p);
 
-            tovisit.add(calleeMD);
+            if (!ssjava.isTrustMethod(callerMD) && !ssjava.isTrustMethod(calleeMD)) {
+              // if method is annotated as "TRUST", do not need to check for
+              // linear type & flow-down rule
+              tovisit.add(calleeMD);
 
-            Set<MethodDescriptor> possibleCalleeSet =
-                (Set<MethodDescriptor>) ssjava.getCallGraph().getMethods(calleeMD);
+              Set<MethodDescriptor> possibleCalleeSet =
+                  (Set<MethodDescriptor>) ssjava.getCallGraph().getMethods(calleeMD);
 
-            for (Iterator iterator2 = possibleCalleeSet.iterator(); iterator2.hasNext();) {
-              MethodDescriptor possibleCallee = (MethodDescriptor) iterator2.next();
+              for (Iterator iterator2 = possibleCalleeSet.iterator(); iterator2.hasNext();) {
+                MethodDescriptor possibleCallee = (MethodDescriptor) iterator2.next();
 
-              if (!possibleCallee.isAbstract()) {
-                ssjava.addAnnotationRequire(possibleCallee);
-                tovisit.add(possibleCallee);
+                if (!possibleCallee.isAbstract() && !possibleCallee.getModifiers().isNative()) {
+                  ssjava.addAnnotationRequire(possibleCallee);
+                  tovisit.add(possibleCallee);
+                }
               }
-
             }
 
           }
@@ -114,6 +122,19 @@ public class MethodAnnotationCheck {
 
   }
 
+  private void checkTrustworthyMethodAnnotation(MethodDescriptor md) {
+    // method annotation parsing
+    Vector<AnnotationDescriptor> methodAnnotations = md.getModifiers().getAnnotations();
+    if (methodAnnotations != null) {
+      for (int i = 0; i < methodAnnotations.size(); i++) {
+        AnnotationDescriptor an = methodAnnotations.elementAt(i);
+        if (an.getMarker().equals(ssjava.TRUST)) {
+          ssjava.addTrustMethod(md);
+        }
+      }
+    }
+  }
+
   public void methodAnnoataionInheritanceCheck() {
     // check If a method is annotated, any method that overrides it should
     // be annotated.
@@ -144,19 +165,21 @@ public class MethodAnnotationCheck {
       }
 
       // need to check super classess if the current method is inherited from
-      // them, all of ancestor method should be annoated
-      ClassDescriptor currentCd = cd;
-      ClassDescriptor superCd = tu.getSuper(currentCd);
-      while (!superCd.getSymbol().equals("Object")) {
-        Set possiblematches = superCd.getMethodTable().getSet(md.getSymbol());
+      // them, all of ancestor method should be annotated.
+
+      ClassDescriptor curClassDesc;
+      ClassDescriptor parentClassDesc = cd;
+
+      while (!parentClassDesc.getSymbol().equals("Object")) {
+        curClassDesc = parentClassDesc;
+        parentClassDesc = tu.getSuper(curClassDesc);
+        Set possiblematches = parentClassDesc.getMethodTable().getSet(md.getSymbol());
         for (Iterator methodit = possiblematches.iterator(); methodit.hasNext();) {
           MethodDescriptor matchmd = (MethodDescriptor) methodit.next();
           if (md.matches(matchmd)) {
             ssjava.addAnnotationRequire(matchmd);
           }
         }
-        currentCd = superCd;
-        superCd = tu.getSuper(currentCd);
       }
 
       Set<ClassDescriptor> superIFSet = tu.getSuperIFs(cd);
@@ -182,20 +205,10 @@ public class MethodAnnotationCheck {
 
   private void checkBlockNode(MethodDescriptor md, SymbolTable nametable, BlockNode bn, boolean flag) {
     bn.getVarTable().setParent(nametable);
-    String label = bn.getLabel();
-    boolean isSSJavaLoop = flag;
-    if (label != null && label.equals(ssjava.SSJAVA)) {
-      if (isSSJavaLoop) {
-        throw new Error("Only outermost loop can be the self-stabilizing loop.");
-      } else {
-        annotatedMDSet.add(md);
-        isSSJavaLoop = true;
-      }
-    }
 
     for (int i = 0; i < bn.size(); i++) {
       BlockStatementNode bsn = bn.get(i);
-      checkBlockStatementNode(md, bn.getVarTable(), bsn, isSSJavaLoop);
+      checkBlockStatementNode(md, bn.getVarTable(), bsn, flag);
     }
 
   }
@@ -264,9 +277,22 @@ public class MethodAnnotationCheck {
   }
 
   private void checkLoopNode(MethodDescriptor md, SymbolTable nametable, LoopNode ln, boolean flag) {
+
+    String label = ln.getLabel();
+    boolean isSSJavaLoop = flag;
+    if (label != null && label.equals(ssjava.SSJAVA)) {
+      if (isSSJavaLoop) {
+        throw new Error("Only outermost loop can be the self-stabilizing loop.");
+      } else {
+        ssjava.setMethodContainingSSJavaLoop(md);
+        annotatedMDSet.add(md);
+        isSSJavaLoop = true;
+      }
+    }
+
     if (ln.getType() == LoopNode.WHILELOOP || ln.getType() == LoopNode.DOWHILELOOP) {
-      checkExpressionNode(md, nametable, ln.getCondition(), flag);
-      checkBlockNode(md, nametable, ln.getBody(), flag);
+      checkExpressionNode(md, nametable, ln.getCondition(), isSSJavaLoop);
+      checkBlockNode(md, nametable, ln.getBody(), isSSJavaLoop);
     } else {
       // For loop case
       /* Link in the initializer naming environment */
@@ -274,12 +300,12 @@ public class MethodAnnotationCheck {
       bn.getVarTable().setParent(nametable);
       for (int i = 0; i < bn.size(); i++) {
         BlockStatementNode bsn = bn.get(i);
-        checkBlockStatementNode(md, bn.getVarTable(), bsn, flag);
+        checkBlockStatementNode(md, bn.getVarTable(), bsn, isSSJavaLoop);
       }
       // check the condition
-      checkExpressionNode(md, bn.getVarTable(), ln.getCondition(), flag);
-      checkBlockNode(md, bn.getVarTable(), ln.getBody(), flag);
-      checkBlockNode(md, bn.getVarTable(), ln.getUpdate(), flag);
+      checkExpressionNode(md, bn.getVarTable(), ln.getCondition(), isSSJavaLoop);
+      checkBlockNode(md, bn.getVarTable(), ln.getBody(), isSSJavaLoop);
+      checkBlockNode(md, bn.getVarTable(), ln.getUpdate(), isSSJavaLoop);
     }
   }