adding files

diff --git a/Robust/src/IR/ClassDescriptor.java b/Robust/src/IR/ClassDescriptor.java
new file mode 100644 (file)
index 0000000..353ab00
--- /dev/null
+++ b/Robust/src/IR/ClassDescriptor.java
@@ -0,0 +1,68 @@
+package IR;
+import java.util.*;
+import IR.Tree.*;
+import IR.FieldDescriptor;
+import IR.MethodDescriptor;
+import IR.NameDescriptor;
+
+public class ClassDescriptor {
+    public ClassDescriptor() {
+       classname=null;
+       superclass=null;
+       fields=new Vector();
+       methods=new Vector();
+    }
+    String classname;
+    NameDescriptor superclass;
+    Modifiers modifiers;
+    Vector fields;
+    Vector methods;
+    
+    public Iterator getMethods() {
+       return methods.iterator();
+    }
+    
+    public String printTree(State state) {
+       int indent;
+       String st=modifiers.toString()+"class "+classname;
+       if (superclass!=null) 
+           st+="extends "+superclass.toString();
+       st+=" {\n";
+       indent=TreeNode.INDENT;
+       for(int i=0;i<fields.size();i++) {
+           FieldDescriptor fd=(FieldDescriptor)fields.get(i);
+           st+=TreeNode.printSpace(indent)+fd.toString()+"\n";
+       }
+       if (fields.size()>0)
+           st+="\n";
+
+       for(int i=0;i<methods.size();i++) {
+           MethodDescriptor md=(MethodDescriptor)methods.get(i);
+           st+=TreeNode.printSpace(indent)+md.toString()+" ";
+           BlockNode bn=state.getMethodBody(md);
+           st+=bn.printNode(indent)+"\n\n";
+       }
+       st+="}\n";
+       return st;
+    }
+
+    public void addField(FieldDescriptor fd) {
+       fields.add(fd);
+    }
+
+    public void addMethod(MethodDescriptor md) {
+       methods.add(md);
+    }
+  
+    public void setModifiers(Modifiers modifiers) {
+       this.modifiers=modifiers;
+    }
+
+    public void setName(String name) {
+       classname=name;
+    }
+
+    public void setSuper(NameDescriptor superclass) {
+       this.superclass=superclass;
+    }
+}

diff --git a/Robust/src/IR/Flat/BuildFlat.java b/Robust/src/IR/Flat/BuildFlat.java
new file mode 100644 (file)
index 0000000..32f6555
--- /dev/null
+++ b/Robust/src/IR/Flat/BuildFlat.java
@@ -0,0 +1,54 @@
+package IR.Flat;
+import IR.*;
+import IR.Tree.*;
+import java.util.*;
+
+public class BuildFlat {
+    State state;
+    public BuildFlat(State st) {
+       state=st;
+    }
+
+    public void buildflat() {
+       Iterator it=state.classset.iterator();
+       while(it.hasNext()) {
+           ClassDescriptor cn=(ClassDescriptor)it.next();
+           flattenClass(cn);
+       }
+    }
+    
+    private void flattenClass(ClassDescriptor cn) {
+       Iterator methodit=cn.getMethods();
+       while(methodit.hasNext()) {
+           MethodDescriptor md=(MethodDescriptor)methodit.next();
+           BlockNode bn=state.getMethodBody(md);
+           FlatNode fn=flattenBlockNode(bn).getBegin();
+           FlatMethod fm=new FlatMethod(md, fn);
+           state.addFlatCode(md,fm);
+       }
+    }
+
+    private NodePair flattenBlockNode(BlockNode bn) {
+       FlatNode begin=null;
+       FlatNode end=null;
+       for(int i=0;i<bn.size();i++) {
+           NodePair np=flattenBlockStatementNode(bn.get(i));
+           FlatNode np_begin=np.getBegin();
+           FlatNode np_end=np.getEnd();
+           if (begin==null) {
+               begin=np_begin;
+           }
+           if (end==null) {
+               end=np_end;
+           } else {
+               end.addNext(np_begin);
+               end=np_end;
+           }
+       }
+       return new NodePair(begin,end);
+    }
+
+    private NodePair flattenBlockStatementNode(BlockStatementNode bsn) {
+       return null;
+    }
+}

diff --git a/Robust/src/IR/Flat/FlatMethod.java b/Robust/src/IR/Flat/FlatMethod.java
new file mode 100644 (file)
index 0000000..53c4e6c
--- /dev/null
+++ b/Robust/src/IR/Flat/FlatMethod.java
@@ -0,0 +1,16 @@
+package IR.Flat;
+import IR.MethodDescriptor;
+
+public class FlatMethod extends FlatNode {
+    FlatNode method_entry;
+    MethodDescriptor method;
+
+    FlatMethod(MethodDescriptor md, FlatNode entry) {
+       method=md;
+       method_entry=entry;
+    }
+    
+    public String toString() {
+       return method.toString()+"\n"+method_entry.toString();
+    }
+}

diff --git a/Robust/src/IR/Flat/NodePair.java b/Robust/src/IR/Flat/NodePair.java
new file mode 100644 (file)
index 0000000..f9164ff
--- /dev/null
+++ b/Robust/src/IR/Flat/NodePair.java
@@ -0,0 +1,19 @@
+package IR.Flat;
+
+public class NodePair {
+    FlatNode begin;
+    FlatNode end;
+
+    public NodePair(FlatNode begin, FlatNode end) {
+       this.begin=begin;
+       this.end=end;
+    }
+
+    public FlatNode getBegin() {
+       return begin;
+    }
+
+    public FlatNode getEnd() {
+       return end;
+    }
+}

diff --git a/Robust/src/IR/Flat/ReturnNode.java b/Robust/src/IR/Flat/ReturnNode.java
new file mode 100644 (file)
index 0000000..4ee9adb
--- /dev/null
+++ b/Robust/src/IR/Flat/ReturnNode.java
@@ -0,0 +1,8 @@
+public class ReturnNode extends FlatNode {
+    public ReturnNode() {
+    }
+
+    
+
+
+}

diff --git a/Robust/src/IR/Tree/Kind.java b/Robust/src/IR/Tree/Kind.java
new file mode 100644 (file)
index 0000000..cb2ea78
--- /dev/null
+++ b/Robust/src/IR/Tree/Kind.java
@@ -0,0 +1,19 @@
+package IR.Tree;
+
+public class Kind {
+    public final static int AssignmentNode=1;
+    public final static int OpNode=2;
+    public final static int BlockExpressionNode=3;
+    public final static int FieldAccessNode=4;
+    public final static int BlockNode=5;
+    public final static int IfStatementNode=6;
+    public final static int ReturnNode=7;
+    public final static int LiteralNode=8;
+    public final static int SubBlockNode=9;
+    public final static int CastNode=10;
+    public final static int LoopNode=11;
+    public final static int CreateObjectNode=12;
+    public final static int MethodInvokeNode=13;
+    public final static int DeclarationNode=14;
+    public final static int NameNode=15;
+}