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 flattenExpressionNode(ExpressionNode en) {
  52
  53     }
  54
  55     private NodePair flattenDeclarationNode(DeclarationNode dn) {
  56
  57     }
  58
  59     private NodePair flattenIfStatementNode(IfStatementNode isn) {
  60
  61     }
  62
  63     private NodePair flattenLoopNode(LoopNode ln) {
  64
  65     }
  66
  67     private NodePair flattenReturnNode(ReturnNode rn) {
  68
  69     }
  70
  71     private NodePair flattenSubBlockNode(SubBlockNode sbn) {
  72
  73     }
  74
  75     private NodePair flattenBlockStatementNode(BlockStatementNode bsn) {
  76         switch(bsn.kind()) {
  77         case Kind.BlockExpressionNode:
  78             return flattenExpressionNode((ExpressionNode)bsn);
  79
  80         case Kind.DeclarationNode:
  81             return flattenDeclarationNode((DeclarationNode)bsn);
  82
  83         case Kind.IfStatementNode:
  84             return flattenIfStatementNode((IfStatementNode)bsn);
  85
  86         case Kind.LoopNode:
  87             return flattenLoopNode((LoopNode)bsn);
  88
  89         case Kind.ReturnNode:
  90             return flattenReturnNode((ReturnNode)bsn);
  91
  92         case Kind.SubBlockNode:
  93             return flattenSubBlockNode((SubBlockNode)bsn);
  94
  95         }
  96         throw new Error();
  97     }
  98 }