Robust/src/Analysis/OwnershipAnalysis/MethodEffectsAnalysis.java

   1 package Analysis.OwnershipAnalysis;
   2
   3 import java.io.BufferedWriter;
   4 import java.io.FileWriter;
   5 import java.io.IOException;
   6 import java.util.Hashtable;
   7 import java.util.Iterator;
   8 import java.util.Set;
   9
  10 import IR.FieldDescriptor;
  11 import IR.MethodDescriptor;
  12 import IR.TypeDescriptor;
  13 import IR.Flat.FlatCall;
  14 import IR.Flat.FlatSetElementNode;
  15 import IR.Flat.TempDescriptor;
  16
  17 public class MethodEffectsAnalysis {
  18
  19         private Hashtable<MethodContext, MethodEffects> mapMethodContextToMethodEffects;
  20         boolean methodeffects = false;
  21
  22         public MethodEffectsAnalysis(boolean methodeffects) {
  23                 this.methodeffects = methodeffects;
  24                 mapMethodContextToMethodEffects = new Hashtable<MethodContext, MethodEffects>();
  25         }
  26
  27         public MethodEffects getMethodEffectsByMethodContext(MethodContext mc){
  28                 return mapMethodContextToMethodEffects.get(mc);
  29         }
  30
  31         public void createNewMapping(MethodContext mcNew) {
  32                 if(!methodeffects) return;
  33                 if (!mapMethodContextToMethodEffects.containsKey(mcNew)) {
  34                         MethodEffects meNew = new MethodEffects();
  35                         mapMethodContextToMethodEffects.put(mcNew, meNew);
  36                 }
  37         }
  38
  39         public void analyzeFlatCall(OwnershipGraph calleeOG,
  40                         MethodContext calleeMC, MethodContext callerMC, FlatCall fc) {
  41                 if(!methodeffects) return;
  42                 MethodEffects me = mapMethodContextToMethodEffects.get(callerMC);
  43                 MethodEffects meFlatCall = mapMethodContextToMethodEffects
  44                                 .get(calleeMC);
  45                 me.analyzeFlatCall(calleeOG, fc, callerMC, meFlatCall);
  46                 mapMethodContextToMethodEffects.put(callerMC, me);
  47         }
  48
  49         public void analyzeFlatFieldNode(MethodContext mc, OwnershipGraph og,
  50                         TempDescriptor srcDesc, FieldDescriptor fieldDesc) {
  51                 if(!methodeffects) return;
  52                 MethodEffects me = mapMethodContextToMethodEffects.get(mc);
  53                 me.analyzeFlatFieldNode(og, srcDesc, fieldDesc);
  54                 mapMethodContextToMethodEffects.put(mc, me);
  55         }
  56
  57         public void analyzeFlatSetFieldNode(MethodContext mc, OwnershipGraph og,
  58                         TempDescriptor dstDesc, FieldDescriptor fieldDesc) {
  59                 if(!methodeffects) return;
  60                 MethodEffects me = mapMethodContextToMethodEffects.get(mc);
  61                 me.analyzeFlatSetFieldNode(og, dstDesc, fieldDesc);
  62                 mapMethodContextToMethodEffects.put(mc, me);
  63         }
  64
  65         public void analyzeFlatSetElementNode(MethodContext mc, OwnershipGraph og,
  66                         TempDescriptor dstDesc, FieldDescriptor fieldDesc) {
  67                 if(!methodeffects) return;
  68                 MethodEffects me = mapMethodContextToMethodEffects.get(mc);
  69                 me.analyzeFlatSetElementNode(og, dstDesc, fieldDesc);
  70                 mapMethodContextToMethodEffects.put(mc, me);
  71         }
  72
  73         public void analyzeFlatElementNode(MethodContext mc, OwnershipGraph og,
  74                         TempDescriptor dstDesc, FieldDescriptor fieldDesc) {
  75                 if(!methodeffects) return;
  76                 MethodEffects me = mapMethodContextToMethodEffects.get(mc);
  77                 me.analyzeFlatElementNode(og, dstDesc, fieldDesc);
  78                 mapMethodContextToMethodEffects.put(mc, me);
  79         }
  80
  81
  82         public void writeMethodEffectsResult() throws IOException {
  83
  84                 try {
  85                         BufferedWriter bw = new BufferedWriter(new FileWriter(
  86                                         "MethodEffects_report.txt"));
  87
  88                         Set<MethodContext> mcSet = mapMethodContextToMethodEffects.keySet();
  89                         Iterator<MethodContext> mcIter = mcSet.iterator();
  90                         while (mcIter.hasNext()) {
  91                                 MethodContext mc = mcIter.next();
  92                                 MethodDescriptor md = (MethodDescriptor) mc.getDescriptor();
  93
  94                                 int startIdx = 0;
  95                                 if (!md.isStatic()) {
  96                                         startIdx = 1;
  97                                 }
  98
  99                                 MethodEffects me = mapMethodContextToMethodEffects.get(mc);
 100                                 EffectsSet effectsSet = me.getEffects();
 101
 102                                 bw.write("Method " + mc + " :\n");
 103                                 for (int i = startIdx; i < md.numParameters() + startIdx; i++) {
 104
 105                                         String paramName = md.getParamName(i - startIdx);
 106
 107                                         Set<EffectsKey> effectSet = effectsSet.getReadingSet(i);
 108                                         String keyStr = "{";
 109                                         if (effectSet != null) {
 110                                                 Iterator<EffectsKey> effectIter = effectSet.iterator();
 111                                                 while (effectIter.hasNext()) {
 112                                                         EffectsKey key = effectIter.next();
 113                                                         keyStr += " " + key;
 114                                                 }
 115                                         }
 116                                         keyStr += " }";
 117                                         bw.write("  Paramter " + paramName + " ReadingSet="
 118                                                         + keyStr + "\n");
 119
 120                                         effectSet = effectsSet.getWritingSet(new Integer(i));
 121                                         keyStr = "{";
 122                                         if (effectSet != null) {
 123                                                 Iterator<EffectsKey> effectIter = effectSet.iterator();
 124                                                 while (effectIter.hasNext()) {
 125                                                         EffectsKey key = effectIter.next();
 126                                                         keyStr += " " + key;
 127                                                 }
 128                                         }
 129
 130                                         keyStr += " }";
 131                                         bw.write("  Paramter " + paramName + " WritingngSet="
 132                                                         + keyStr + "\n");
 133
 134                                 }
 135                                 bw.write("\n");
 136
 137                         }
 138
 139                         bw.close();
 140                 } catch (IOException e) {
 141                         System.err.println(e);
 142                 }
 143
 144         }
 145
 146 }