Repair/RepairCompiler/MCC/IR/ComputeMaxSize.java

   1 package MCC.IR;
   2 import MCC.State;
   3 import java.util.*;
   4
   5 /** This class computes the maximum size of sets and relations */
   6
   7 public class ComputeMaxSize {
   8     State state;
   9     Hashtable sizemap; /* -1 means infinity */
  10
  11
  12     public ComputeMaxSize(State state) {
  13         this.state=state;
  14         sizemap=new Hashtable();
  15         computesizes();
  16     }
  17
  18     /** This method compute relation and set maximum sizes */
  19     private void computesizes() {
  20         Vector rules=state.vRules;
  21         boolean change=true;
  22         Set descriptorset=new HashSet();
  23         descriptorset.addAll(state.stSets.getAllDescriptors());
  24         descriptorset.addAll(state.stRelations.getAllDescriptors());
  25         while(change) {
  26             change=false;
  27             for(Iterator dit=descriptorset.iterator();dit.hasNext();) {
  28                 Descriptor d=(Descriptor)dit.next();
  29                 if (d instanceof ReservedSetDescriptor)
  30                     continue;
  31                 int totalsize=0;
  32                 for(int i=0;i<rules.size();i++) {
  33                     Rule r=(Rule)rules.get(i);
  34                     if (r.getInclusion().getTargetDescriptors().contains(d)) {
  35                         /* This rule may add items to this set or relation */
  36                         int rulesize=1;
  37                         for(int j=0;j<r.numQuantifiers();j++) {
  38                             Quantifier q=r.getQuantifier(j);
  39                             int size=0;
  40                             if (q instanceof RelationQuantifier) {
  41                                 Descriptor d2=((RelationQuantifier)q).getRelation();
  42                                 if (sizemap.containsKey(d2)) {
  43                                     size=((Integer)sizemap.get(d2)).intValue();
  44                                 }
  45                                 if ((size!=0)&&(d==d2))
  46                                     size=-1;
  47                             } if (q instanceof SetQuantifier) {
  48                                 Descriptor d2=((SetQuantifier)q).getSet();
  49                                 if (sizemap.containsKey(d2)) {
  50                                     size=((Integer)sizemap.get(d2)).intValue();
  51                                 }
  52                                 if ((size!=0)&&(d==d2))
  53                                     size=-1;
  54                             } else {
  55                                 size=-1;
  56                             }
  57                             if ((rulesize!=0)&&((size==-1)||(rulesize==-1)))
  58                                 rulesize=-1;
  59                             else
  60                                 rulesize=rulesize*size;
  61                         }
  62
  63                         if ((rulesize==-1)||(totalsize==-1))
  64                             totalsize=-1;
  65                         else
  66                             totalsize+=rulesize;
  67                     }
  68                 }
  69                 if (!sizemap.containsKey(d)||((Integer)sizemap.get(d)).intValue()!=totalsize) {
  70                     change=true;
  71                     sizemap.put(d,new Integer(totalsize));
  72                 }
  73             }
  74         }
  75     }
  76     int getsize(Descriptor d) {
  77         return ((Integer)sizemap.get(d)).intValue();
  78     }
  79 }
  80