Repair/RepairCompiler/MCC/IR/Updates.java

   1 package MCC.IR;
   2
   3 class Updates {
   4     static public final int EXPR=0;
   5     static public final int POSITION=1;
   6     static public final int ACCESSPATH=2;
   7     static public final int ABSTRACT=3;
   8
   9     int type=-1;
  10     int rightposition;
  11     Expr rightexpr;
  12     Expr leftexpr;
  13     Opcode opcode;
  14     boolean negate=false;
  15     ArrayAnalysis.AccessPath ap;
  16     int fieldnum;
  17
  18     public Updates(Expr lexpr, int fieldnum, ArrayAnalysis.AccessPath ap, Expr rexpr, int slot) {
  19         this.leftexpr=lexpr;
  20         this.fieldnum=fieldnum;
  21         this.ap=ap;
  22         this.rightposition=slot;
  23         this.rightexpr=rexpr;
  24         this.type=Updates.ACCESSPATH;
  25         this.opcode=Opcode.EQ;
  26     }
  27
  28     public Updates(Expr lexpr, Expr rexpr, Opcode op, boolean negate) {
  29         if (!lexpr.isValue(null))
  30             System.out.println("Building invalid update");
  31         leftexpr=lexpr;
  32         type=Updates.EXPR;
  33
  34         op=Opcode.translateOpcode(negate,op);
  35
  36         opcode=op;
  37         rightexpr=rexpr;
  38     }
  39
  40     public Updates(Expr lexpr, Expr rexpr) {
  41         if (!lexpr.isValue(null))
  42             System.out.println("Building invalid update");
  43         leftexpr=lexpr;
  44         rightexpr=rexpr;
  45         type=Updates.EXPR;
  46         opcode=Opcode.EQ;
  47     }
  48
  49     public Updates(Expr lexpr, int rpos, TypeDescriptor td) {
  50         if (!lexpr.isValue(td))
  51             System.out.println("Building invalid update");
  52         leftexpr=lexpr;
  53         rightposition=rpos;
  54         type=Updates.POSITION;
  55         opcode=Opcode.EQ;
  56     }
  57
  58     public Updates(Expr lexpr,boolean negates) {
  59         leftexpr=lexpr;
  60         type=Updates.ABSTRACT;
  61         negate=negates;
  62         opcode=null;
  63     }
  64
  65     VarDescriptor getVar() {
  66         if (isGlobal()) {
  67             return ((VarExpr)leftexpr).getVar();
  68         } else if (isField()) {
  69             Expr e=leftexpr;
  70             do {
  71                 for(;e instanceof DotExpr;e=((DotExpr)e).getExpr()) ;
  72                 if (e instanceof VarExpr)
  73                     break;
  74                 if (e instanceof CastExpr)
  75                     e=((CastExpr)e).getExpr();
  76                 else throw new Error("Unrecognized Expr:"+e.name());
  77             } while(true);
  78             return ((VarExpr)e).getVar();
  79         } else {
  80             System.out.println(toString());
  81             throw new Error("Unrecognized Update");
  82         }
  83     }
  84
  85     Descriptor getDescriptor() {
  86         Expr lexpr=leftexpr;
  87         while (lexpr instanceof CastExpr)
  88             lexpr=((CastExpr)lexpr).getExpr();
  89
  90         if (isGlobal()) {
  91             return ((VarExpr)lexpr).getVar();
  92         } else if (isField()) {
  93             return ((DotExpr)lexpr).getField();
  94         } else {
  95             System.out.println(toString());
  96             throw new Error("Unrecognized Update");
  97         }
  98     }
  99
 100     boolean isGlobal() {
 101         Expr lexpr=leftexpr;
 102         while (lexpr instanceof CastExpr)
 103             lexpr=((CastExpr)lexpr).getExpr();
 104
 105         if (lexpr instanceof VarExpr)
 106             return true;
 107         else return false;
 108     }
 109
 110     boolean isField() {
 111         Expr lexpr=leftexpr;
 112         while (lexpr instanceof CastExpr)
 113             lexpr=((CastExpr)lexpr).getExpr();
 114
 115         if (lexpr instanceof DotExpr) {
 116             assert ((DotExpr)lexpr).getIndex()==null;
 117             return true;
 118         } else
 119             return false;
 120     }
 121
 122     boolean isExpr() {
 123         return type==Updates.EXPR;
 124     }
 125
 126
 127     Opcode getOpcode() {
 128         return opcode;
 129     }
 130
 131     boolean isAbstract() {
 132         return type==Updates.ABSTRACT;
 133     }
 134
 135     public int getType() {
 136         return type;
 137     }
 138
 139     public Expr getLeftExpr() {
 140         return leftexpr;
 141     }
 142
 143     public int getRightPos() {
 144         assert type==Updates.POSITION||type==Updates.ACCESSPATH;
 145         return rightposition;
 146     }
 147
 148     public Expr getRightExpr() {
 149         assert type==Updates.EXPR;
 150         return rightexpr;
 151     }
 152
 153     public int getFieldNum() {
 154         assert type==Updates.ACCESSPATH;
 155         return fieldnum;
 156     }
 157
 158     public ArrayAnalysis.AccessPath getAccessPath() {
 159         assert type==Updates.ACCESSPATH;
 160         return ap;
 161     }
 162
 163     public String toString() {
 164         if (type==EXPR)
 165             return leftexpr.name()+opcode.toString()+rightexpr.name();
 166         else if (type==POSITION)
 167             return leftexpr.name()+opcode.toString()+"Position("+String.valueOf(rightposition)+")";
 168         else if (type==ACCESSPATH) {
 169             return leftexpr.name()+opcode.toString()+"Field("+fieldnum+","+ap+") of Position("+String.valueOf(rightposition)+")";
 170         } else if (type==ABSTRACT) {
 171             if (negate) return "!"+leftexpr.name();
 172             else return leftexpr.name();
 173         } else throw new Error("Unrecognized type");
 174     }
 175 }