Repair/RepairCompiler/MCC/IR/DependencyBuilder.java

   1 package MCC.IR;
   2
   3 import MCC.State;
   4 import java.util.*;
   5
   6 public class DependencyBuilder {
   7
   8     Hashtable constraintnodes = new Hashtable();
   9     Hashtable rulenodes = new Hashtable();
  10     State state;
  11
  12     public DependencyBuilder(State state) {
  13         this.state = state;
  14     }
  15
  16     public void calculate() {
  17         /* reinitialize (clear) nodes */
  18         constraintnodes = new Hashtable();
  19         rulenodes = new Hashtable();
  20
  21         /* load up the rules and constraints */
  22         Vector rules = state.vRules;
  23         Vector constraints = state.vConstraints;
  24
  25         /* build up graph rulenodes (not edges yet) */
  26         for (int i = 0; i < rules.size(); i++) {
  27             Rule rule = (Rule) rules.elementAt(i);
  28             assert rule != null;
  29             assert rule.getLabel() != null;
  30
  31             Inclusion inclusion = rule.getInclusion();
  32             Iterator targets = inclusion.getTargetDescriptors().iterator();
  33             String additionallabel = new String();
  34
  35             /* #ATTN#: is this meant to be while, not if? */
  36             /* perhaps there is only one descriptor for targets */
  37             if (targets.hasNext()) {
  38                 Descriptor d = (Descriptor)targets.next();
  39                 additionallabel = "\\n" + d.getSymbol();
  40             }
  41
  42             GraphNode gn = new GraphNode(rule.getLabel(), rule.getLabel() + additionallabel, rule);
  43             rulenodes.put(rule.getLabel(), gn);
  44         }
  45
  46         /* build up graph constraintnodes (not edges yet) */
  47         for (int i = 0; i < constraints.size(); i++) {
  48             Constraint constraint = (Constraint) constraints.elementAt(i);
  49             assert constraint != null;
  50             assert constraint.getLabel() != null;
  51             GraphNode gn = new GraphNode(constraint.getLabel(), constraint);
  52             gn.setDotNodeParameters("shape=box");
  53             constraintnodes.put(constraint.getLabel(), gn);
  54         }
  55
  56         /* calculate rule->rule dependencies */
  57         for (int i = 0; i < rules.size(); i++) {
  58             Rule rule = (Rule) rules.elementAt(i);
  59             GraphNode rulenode = (GraphNode) rulenodes.get(rule.getLabel());
  60             Set requiredsymbols = rule.getRequiredDescriptors();
  61             requiredsymbols.addAll(rule.getInclusion().getRequiredDescriptors());
  62
  63             for (int j = 0; j < rules.size(); j++) {
  64
  65                 if (j == i) {
  66                     continue;
  67                 }
  68
  69                 Rule otherrule = (Rule) rules.elementAt(j);
  70                 Inclusion inclusion = otherrule.getInclusion();
  71                 Iterator targets = inclusion.getTargetDescriptors().iterator();
  72                 GraphNode otherrulenode = (GraphNode) rulenodes.get(otherrule.getLabel());
  73
  74                 while (targets.hasNext()) {
  75                     Descriptor d = (Descriptor) targets.next();
  76
  77                     if (requiredsymbols.contains(d)) { /* rule->rule dependency */
  78                         otherrulenode.addEdge(new GraphNode.Edge(d.getSymbol(), rulenode));
  79                     }
  80                 }
  81             }
  82         }
  83
  84         /* build constraint->rule dependencies */
  85         for (int i = 0; i < constraints.size(); i++) {
  86             Constraint constraint = (Constraint) constraints.elementAt(i);
  87             GraphNode constraintnode = (GraphNode) constraintnodes.get(constraint.getLabel());
  88             Set requiredsymbols = constraint.getRequiredDescriptorsFromLogicStatement();
  89             Set requiredquantifiers = constraint.getRequiredDescriptorsFromQuantifiers();
  90
  91             for (int j = 0; j < rules.size(); j++) {
  92                 Rule otherrule = (Rule) rules.elementAt(j);
  93                 Inclusion inclusion = otherrule.getInclusion();
  94                 Iterator targets = inclusion.getTargetDescriptors().iterator();
  95                 GraphNode otherrulenode = (GraphNode) rulenodes.get(otherrule.getLabel());
  96
  97                 while (targets.hasNext()) {
  98                     Descriptor d = (Descriptor) targets.next();
  99
 100                     if (requiredsymbols.contains(d)) { /* logic->rule dependency */
 101                         GraphNode.Edge edge = new GraphNode.Edge(d.getSymbol(), constraintnode);
 102                         //edge.setDotNodeParameters("style=bold");
 103                         otherrulenode.addEdge(edge);
 104                     }
 105
 106                     if (requiredquantifiers.contains(d)) { /* quantifier-> dependency */
 107                         GraphNode.Edge edge = new GraphNode.Edge(d.getSymbol(), constraintnode);
 108                         edge.setDotNodeParameters("style=dotted");
 109                         otherrulenode.addEdge(edge);
 110                     }
 111                 }
 112             }
 113         }
 114
 115         /* store results in state */
 116         state.rulenodes = rulenodes;
 117         state.constraintnodes = constraintnodes;
 118     }
 119 }