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         throw new Error();
  53     }
  54
  55     private NodePair flattenExpressionNode(ExpressionNode en) {
  56         throw new Error();
  57     }
  58
  59     private NodePair flattenDeclarationNode(DeclarationNode dn) {
  60         throw new Error();
  61     }
  62
  63     private NodePair flattenIfStatementNode(IfStatementNode isn) {
  64         throw new Error();
  65     }
  66
  67     private NodePair flattenLoopNode(LoopNode ln) {
  68         if (ln.getType()==LoopNode.FORLOOP) {
  69             NodePair initializer=flattenBlockNode(ln.getInitializer());
  70             TempDescriptor cond_temp=TempDescriptor.tempFactory("condition");
  71             NodePair condition=flattenExpressionNode(ln.getCondition());
  72             NodePair update=flattenBlockNode(ln.getUpdate());
  73             NodePair body=flattenBlockNode(ln.getBody());
  74             FlatNode begin=initializer.getBegin();
  75             FlatCondBranch fcb=new FlatCondBranch(cond_temp);
  76             FlatNop nopend=new FlatNop();
  77
  78             initializer.getEnd().addNext(condition.getBegin());
  79             body.getEnd().addNext(update.getBegin());
  80             update.getEnd().addNext(condition.getBegin());
  81             condition.getEnd().addNext(fcb);
  82             fcb.addFalseNext(nopend);
  83             fcb.addTrueNext(body.getBegin());
  84             return new NodePair(begin,nopend);
  85         } else if (ln.getType()==LoopNode.WHILELOOP) {
  86             TempDescriptor cond_temp=TempDescriptor.tempFactory("condition");
  87             NodePair condition=flattenExpressionNode(ln.getCondition());
  88             NodePair body=flattenBlockNode(ln.getBody());
  89             FlatNode begin=condition.getBegin();
  90             FlatCondBranch fcb=new FlatCondBranch(cond_temp);
  91             FlatNop nopend=new FlatNop();
  92
  93             body.getEnd().addNext(condition.getBegin());
  94             condition.getEnd().addNext(fcb);
  95             fcb.addFalseNext(nopend);
  96             fcb.addTrueNext(body.getBegin());
  97             return new NodePair(begin,nopend);
  98         } else if (ln.getType()==LoopNode.DOWHILELOOP) {
  99             TempDescriptor cond_temp=TempDescriptor.tempFactory("condition");
 100             NodePair condition=flattenExpressionNode(ln.getCondition());
 101             NodePair body=flattenBlockNode(ln.getBody());
 102             FlatNode begin=body.getBegin();
 103             FlatCondBranch fcb=new FlatCondBranch(cond_temp);
 104             FlatNop nopend=new FlatNop();
 105
 106             body.getEnd().addNext(condition.getBegin());
 107             condition.getEnd().addNext(fcb);
 108             fcb.addFalseNext(nopend);
 109             fcb.addTrueNext(body.getBegin());
 110             return new NodePair(begin,nopend);
 111         } else throw new Error();
 112     }
 113
 114     private NodePair flattenReturnNode(IR.Tree.ReturnNode rntree) {
 115         throw new Error();
 116     }
 117
 118     private NodePair flattenSubBlockNode(SubBlockNode sbn) {
 119         return flattenBlockNode(sbn.getBlockNode());
 120     }
 121
 122     private NodePair flattenBlockStatementNode(BlockStatementNode bsn) {
 123         switch(bsn.kind()) {
 124         case Kind.BlockExpressionNode:
 125             return flattenBlockExpressionNode((BlockExpressionNode)bsn);
 126
 127         case Kind.DeclarationNode:
 128             return flattenDeclarationNode((DeclarationNode)bsn);
 129
 130         case Kind.IfStatementNode:
 131             return flattenIfStatementNode((IfStatementNode)bsn);
 132
 133         case Kind.LoopNode:
 134             return flattenLoopNode((LoopNode)bsn);
 135
 136         case Kind.ReturnNode:
 137             return flattenReturnNode((IR.Tree.ReturnNode)bsn);
 138
 139         case Kind.SubBlockNode:
 140             return flattenSubBlockNode((SubBlockNode)bsn);
 141
 142         }
 143         throw new Error();
 144     }
 145 }