Robust/src/IR/Flat/BuildFlat.java

   1 package IR.Flat;
   2 import IR.*;
   3 import IR.Tree.*;
   4 import java.util.*;
   5
   6 public class BuildFlat {
   7     State state;
   8     public BuildFlat(State st) {
   9         state=st;
  10     }
  11
  12     public void buildFlat() {
  13         Iterator it=state.classset.iterator();
  14         while(it.hasNext()) {
  15             ClassDescriptor cn=(ClassDescriptor)it.next();
  16             flattenClass(cn);
  17         }
  18     }
  19
  20     private void flattenClass(ClassDescriptor cn) {
  21         Iterator methodit=cn.getMethods();
  22         while(methodit.hasNext()) {
  23             MethodDescriptor md=(MethodDescriptor)methodit.next();
  24             BlockNode bn=state.getMethodBody(md);
  25             FlatNode fn=flattenBlockNode(bn).getBegin();
  26             FlatMethod fm=new FlatMethod(md, fn);
  27             state.addFlatCode(md,fm);
  28         }
  29     }
  30
  31     private NodePair flattenBlockNode(BlockNode bn) {
  32         FlatNode begin=null;
  33         FlatNode end=null;
  34         for(int i=0;i<bn.size();i++) {
  35             NodePair np=flattenBlockStatementNode(bn.get(i));
  36             FlatNode np_begin=np.getBegin();
  37             FlatNode np_end=np.getEnd();
  38             if (begin==null) {
  39                 begin=np_begin;
  40             }
  41             if (end==null) {
  42                 end=np_end;
  43             } else {
  44                 end.addNext(np_begin);
  45                 end=np_end;
  46             }
  47         }
  48         return new NodePair(begin,end);
  49     }
  50
  51     private NodePair flattenBlockExpressionNode(BlockExpressionNode en) {
  52         TempDescriptor tmp=TempDescriptor.tempFactory("neverused");
  53         return flattenExpressionNode(en.getExpression(),tmp);
  54     }
  55
  56     private NodePair flattenAssignmentNode(AssignmentNode an,TempDescriptor out_temp) {
  57         throw new Error();
  58     }
  59
  60     private NodePair flattenCastNode(CastNode cn,TempDescriptor out_temp) {
  61         throw new Error();
  62     }
  63
  64     private NodePair flattenCreateObjectNode(CreateObjectNode con,TempDescriptor out_temp) {
  65         throw new Error();
  66     }
  67
  68     private NodePair flattenFieldAccessNode(FieldAccessNode fan,TempDescriptor out_temp) {
  69         throw new Error();
  70     }
  71
  72     private NodePair flattenLiteralNode(LiteralNode ln,TempDescriptor out_temp) {
  73         throw new Error();
  74     }
  75
  76     private NodePair flattenMethodInvokeNode(MethodInvokeNode min,TempDescriptor out_temp) {
  77         throw new Error();
  78     }
  79
  80     private NodePair flattenNameNode(NameNode nn,TempDescriptor out_temp) {
  81         throw new Error();
  82     }
  83
  84     private NodePair flattenOpNode(OpNode on,TempDescriptor out_temp) {
  85         throw new Error();
  86     }
  87
  88     private NodePair flattenExpressionNode(ExpressionNode en, TempDescriptor out_temp) {
  89         switch(en.kind()) {
  90         case Kind.AssignmentNode:
  91             return flattenAssignmentNode((AssignmentNode)en,out_temp);
  92         case Kind.CastNode:
  93             return flattenCastNode((CastNode)en,out_temp);
  94         case Kind.CreateObjectNode:
  95             return flattenCreateObjectNode((CreateObjectNode)en,out_temp);
  96         case Kind.FieldAccessNode:
  97             return flattenFieldAccessNode((FieldAccessNode)en,out_temp);
  98         case Kind.LiteralNode:
  99             return flattenLiteralNode((LiteralNode)en,out_temp);
 100         case Kind.MethodInvokeNode:
 101             return flattenMethodInvokeNode((MethodInvokeNode)en,out_temp);
 102         case Kind.NameNode:
 103             return flattenNameNode((NameNode)en,out_temp);
 104         case Kind.OpNode:
 105             return flattenOpNode((OpNode)en,out_temp);
 106         }
 107         throw new Error();
 108     }
 109
 110     private NodePair flattenDeclarationNode(DeclarationNode dn) {
 111         throw new Error();
 112     }
 113
 114     private NodePair flattenIfStatementNode(IfStatementNode isn) {
 115         TempDescriptor cond_temp=TempDescriptor.tempFactory("condition");
 116         NodePair cond=flattenExpressionNode(isn.getCondition(),cond_temp);
 117         FlatCondBranch fcb=new FlatCondBranch(cond_temp);
 118         NodePair true_np=flattenBlockNode(isn.getTrueBlock());
 119         NodePair false_np;
 120         FlatNop nopend=new FlatNop();
 121
 122         if (isn.getFalseBlock()!=null)
 123             false_np=flattenBlockNode(isn.getFalseBlock());
 124         else {
 125             FlatNop nop=new FlatNop();
 126             false_np=new NodePair(nop,nop);
 127         }
 128
 129         cond.getEnd().addNext(fcb);
 130         fcb.addTrueNext(true_np.getBegin());
 131         fcb.addFalseNext(false_np.getBegin());
 132         true_np.getEnd().addNext(nopend);
 133         false_np.getEnd().addNext(nopend);
 134         return new NodePair(cond.getBegin(), nopend);
 135     }
 136
 137     private NodePair flattenLoopNode(LoopNode ln) {
 138         if (ln.getType()==LoopNode.FORLOOP) {
 139             NodePair initializer=flattenBlockNode(ln.getInitializer());
 140             TempDescriptor cond_temp=TempDescriptor.tempFactory("condition");
 141             NodePair condition=flattenExpressionNode(ln.getCondition(),cond_temp);
 142             NodePair update=flattenBlockNode(ln.getUpdate());
 143             NodePair body=flattenBlockNode(ln.getBody());
 144             FlatNode begin=initializer.getBegin();
 145             FlatCondBranch fcb=new FlatCondBranch(cond_temp);
 146             FlatNop nopend=new FlatNop();
 147
 148             initializer.getEnd().addNext(condition.getBegin());
 149             body.getEnd().addNext(update.getBegin());
 150             update.getEnd().addNext(condition.getBegin());
 151             condition.getEnd().addNext(fcb);
 152             fcb.addFalseNext(nopend);
 153             fcb.addTrueNext(body.getBegin());
 154             return new NodePair(begin,nopend);
 155         } else if (ln.getType()==LoopNode.WHILELOOP) {
 156             TempDescriptor cond_temp=TempDescriptor.tempFactory("condition");
 157             NodePair condition=flattenExpressionNode(ln.getCondition(),cond_temp);
 158             NodePair body=flattenBlockNode(ln.getBody());
 159             FlatNode begin=condition.getBegin();
 160             FlatCondBranch fcb=new FlatCondBranch(cond_temp);
 161             FlatNop nopend=new FlatNop();
 162
 163             body.getEnd().addNext(condition.getBegin());
 164             condition.getEnd().addNext(fcb);
 165             fcb.addFalseNext(nopend);
 166             fcb.addTrueNext(body.getBegin());
 167             return new NodePair(begin,nopend);
 168         } else if (ln.getType()==LoopNode.DOWHILELOOP) {
 169             TempDescriptor cond_temp=TempDescriptor.tempFactory("condition");
 170             NodePair condition=flattenExpressionNode(ln.getCondition(),cond_temp);
 171             NodePair body=flattenBlockNode(ln.getBody());
 172             FlatNode begin=body.getBegin();
 173             FlatCondBranch fcb=new FlatCondBranch(cond_temp);
 174             FlatNop nopend=new FlatNop();
 175
 176             body.getEnd().addNext(condition.getBegin());
 177             condition.getEnd().addNext(fcb);
 178             fcb.addFalseNext(nopend);
 179             fcb.addTrueNext(body.getBegin());
 180             return new NodePair(begin,nopend);
 181         } else throw new Error();
 182     }
 183
 184     private NodePair flattenReturnNode(ReturnNode rntree) {
 185         TempDescriptor retval=TempDescriptor.tempFactory("ret_value");
 186         NodePair cond=flattenExpressionNode(rntree.getReturnExpression(),retval);
 187         FlatReturnNode rnflat=new FlatReturnNode(retval);
 188         cond.getEnd().addNext(rnflat);
 189         return new NodePair(cond.getBegin(),rnflat);
 190     }
 191
 192     private NodePair flattenSubBlockNode(SubBlockNode sbn) {
 193         return flattenBlockNode(sbn.getBlockNode());
 194     }
 195
 196     private NodePair flattenBlockStatementNode(BlockStatementNode bsn) {
 197         switch(bsn.kind()) {
 198         case Kind.BlockExpressionNode:
 199             return flattenBlockExpressionNode((BlockExpressionNode)bsn);
 200
 201         case Kind.DeclarationNode:
 202             return flattenDeclarationNode((DeclarationNode)bsn);
 203
 204         case Kind.IfStatementNode:
 205             return flattenIfStatementNode((IfStatementNode)bsn);
 206
 207         case Kind.LoopNode:
 208             return flattenLoopNode((LoopNode)bsn);
 209
 210         case Kind.ReturnNode:
 211             return flattenReturnNode((IR.Tree.ReturnNode)bsn);
 212
 213         case Kind.SubBlockNode:
 214             return flattenSubBlockNode((SubBlockNode)bsn);
 215
 216         }
 217         throw new Error();
 218     }
 219 }