Other changes

diff --git a/Robust/src/IR/Tree/AssignmentNode.java b/Robust/src/IR/Tree/AssignmentNode.java
index d2d6082a52cabe4280cb48e69d72c05f32508127..7829b41f8f39d648155fa3418bae3cf05bd57462 100644 (file)
--- a/Robust/src/IR/Tree/AssignmentNode.java
+++ b/Robust/src/IR/Tree/AssignmentNode.java
@@ -12,7 +12,7 @@ public class AssignmentNode extends ExpressionNode {
        this.op=op;
     }
 
-    public String printNode() {
-       return left.printNode()+" "+op.toString()+" "+right.printNode();
+    public String printNode(int indent) {
+       return left.printNode(indent)+" "+op.toString()+" "+right.printNode(indent);
     }
 }

diff --git a/Robust/src/IR/Tree/BlockExpressionNode.java b/Robust/src/IR/Tree/BlockExpressionNode.java
index 75824b11bd03903d34c6fdb6a6c5a245d6b48a8d..ca725cff64bb98b1e1f0261c4969b462e8d6c57b 100644 (file)
--- a/Robust/src/IR/Tree/BlockExpressionNode.java
+++ b/Robust/src/IR/Tree/BlockExpressionNode.java
@@ -6,7 +6,7 @@ class BlockExpressionNode extends BlockStatementNode {
        this.en=e;
     }
     
-    public String printNode() {
-       return en.printNode()+";";
+    public String printNode(int indent) {
+       return en.printNode(indent);
     }
 }

diff --git a/Robust/src/IR/Tree/BlockNode.java b/Robust/src/IR/Tree/BlockNode.java
index b7d8719657899112a7d1c627860bd4a98609ca0f..6851ea892bd6ebc2ed73d1f665ca015659b14ef4 100644 (file)
--- a/Robust/src/IR/Tree/BlockNode.java
+++ b/Robust/src/IR/Tree/BlockNode.java
@@ -3,6 +3,11 @@ import java.util.Vector;
 
 class BlockNode extends TreeNode {
     Vector blockstatements;
+    int printStyle=0;
+    public final static int NORMAL=0;
+    public final static int NOBRACES=1;
+    public final static int EXPRLIST=2;
+    
     public BlockNode() {
        blockstatements=new Vector();
     }
@@ -10,14 +15,45 @@ class BlockNode extends TreeNode {
     public void addBlockStatement(BlockStatementNode bsn) {
        blockstatements.add(bsn);
     }
+    public void setStyle(int style) {
+       printStyle=style;
+    }
 
-    public String printNode() {
-       String st="{\n";
-       for(int i=0;i<blockstatements.size();i++) {
-           BlockStatementNode bsn=(BlockStatementNode)blockstatements.get(i);
-           st+=bsn.printNode()+"\n";
-       }
-       st+="}\n";
-       return st;
+    public String printNode(int indent) {
+       if (printStyle==NORMAL) {
+           String st="{\n";
+           for(int i=0;i<blockstatements.size();i++) {
+               BlockStatementNode bsn=(BlockStatementNode)blockstatements.get(i);
+               st+=printSpace(indent+INDENT)+bsn.printNode(indent+INDENT);
+               if (!((bsn instanceof SubBlockNode)||
+                     (bsn instanceof LoopNode)||
+                     (bsn instanceof IfStatementNode)))
+                   st+=";\n";
+               if (bsn instanceof IfStatementNode)
+                   st+="\n";
+           }
+           st+=printSpace(indent)+"}";
+           return st;
+       } else if (printStyle==NOBRACES) {
+           String st="";
+           for(int i=0;i<blockstatements.size();i++) {
+               BlockStatementNode bsn=(BlockStatementNode)blockstatements.get(i);
+               st+=printSpace(indent)+bsn.printNode(indent);
+               if (!((bsn instanceof SubBlockNode)||
+                     (bsn instanceof LoopNode)||
+                     (bsn instanceof IfStatementNode)))
+                   st+=";";
+           }
+           return st;
+       } else if (printStyle==EXPRLIST) {
+           String st="";
+           for(int i=0;i<blockstatements.size();i++) {
+               BlockStatementNode bsn=(BlockStatementNode)blockstatements.get(i);
+               st+=bsn.printNode(0);
+               if ((i+1)!=blockstatements.size())
+                   st+=", ";
+           }
+           return st;
+       } else throw new Error();
     }
 }

diff --git a/Robust/src/IR/Tree/BlockStatementNode.java b/Robust/src/IR/Tree/BlockStatementNode.java
index 001b9b5d75854d8ea182dc9c5cfff04788901fca..23f9a03c83d00ae2d5238f4e3eb4fd1fc7d8879d 100644 (file)
--- a/Robust/src/IR/Tree/BlockStatementNode.java
+++ b/Robust/src/IR/Tree/BlockStatementNode.java
@@ -4,7 +4,7 @@ class BlockStatementNode extends TreeNode {
     public BlockStatementNode() {
     }
     
-    public String printNode() {
+    public String printNode(int indent) {
        return null;
     }
 

diff --git a/Robust/src/IR/Tree/BuildIR.java b/Robust/src/IR/Tree/BuildIR.java
index a4f7c5b6749c45a9520409746aea6f846c40dfe2..68bc9acc46031d7737b4342eca7a37091b44a8c0 100644 (file)
--- a/Robust/src/IR/Tree/BuildIR.java
+++ b/Robust/src/IR/Tree/BuildIR.java
@@ -10,7 +10,7 @@ public class BuildIR {
     public void buildtree() {
        ParseNode pn=state.parsetree;
        FileNode fn=parseFile(pn);
-       System.out.println(fn.printNode());
+       System.out.println(fn.printNode(0));
     }
 
     /** Parse the classes in this file */
@@ -103,10 +103,8 @@ public class BuildIR {
     private NameDescriptor parseName(ParseNode nn) {
        ParseNode base=nn.getChild("base");
        ParseNode id=nn.getChild("identifier");
-       
        if (base==null)
            return new NameDescriptor(id.getTerminal());
-
        return new NameDescriptor(parseName(base.getChild("name")),id.getTerminal());
        
     }
@@ -115,7 +113,6 @@ public class BuildIR {
        ParseNode mn=pn.getChild("modifier");
        Modifiers m=parseModifiersList(mn);
 
-
        ParseNode tn=pn.getChild("type");
        TypeDescriptor t=parseTypeDescriptor(tn);
        ParseNode vn=pn.getChild("variables").getChild("variable_declarators_list");
@@ -200,6 +197,10 @@ public class BuildIR {
            ExpressionNode en=parseExpression(pn.getChild("base").getFirstChild());
            String fieldname=pn.getChild("field").getTerminal();
            return new FieldAccessNode(en,fieldname);
+       } else if (isNode(pn,"cast1")) { 
+           return new CastNode(parseTypeDescriptor(pn.getChild("type")),parseExpression(pn.getChild("exp").getFirstChild()));
+       } else if (isNode(pn,"cast2")) { 
+           return new CastNode(parseExpression(pn.getChild("type").getFirstChild()),parseExpression(pn.getChild("exp").getFirstChild()));
        } else {
            System.out.println("---------------------");
            System.out.println(pn.PPrint(3,true));
@@ -261,6 +262,7 @@ public class BuildIR {
        for(int j=0;j<bsv.size();j++) {
            bn.addBlockStatement((BlockStatementNode)bsv.get(j));
        }
+       bn.setStyle(BlockNode.NOBRACES);
        return bn;
     }
 
@@ -301,11 +303,25 @@ public class BuildIR {
            blockstatements.add(new SubBlockNode(bn));
        } else if (isNode(pn,"empty")) {
            /* nop */
-       } /*else {
+       } else if (isNode(pn,"statement_expression_list")) {
+           ParseNodeVector pnv=pn.getChildren();
+           BlockNode bn=new BlockNode();
+           for(int i=0;i<pnv.size();i++) {
+               ExpressionNode en=parseExpression(pnv.elementAt(i));
+               blockstatements.add(new BlockExpressionNode(en));
+           }
+           bn.setStyle(BlockNode.EXPRLIST);
+       } else if (isNode(pn,"forstatement")) {
+           BlockNode init=parseSingleBlock(pn.getChild("initializer").getFirstChild());
+           BlockNode update=parseSingleBlock(pn.getChild("update").getFirstChild());
+           ExpressionNode condition=parseExpression(pn.getChild("condition").getFirstChild());
+           BlockNode body=parseSingleBlock(pn.getChild("statement").getFirstChild());
+           blockstatements.add(new LoopNode(init,condition,update,body));
+       } else {
            System.out.println("---------------");
            System.out.println(pn.PPrint(3,true));
            throw new Error();
-           }*/
+       }
        return blockstatements;
     }
 

diff --git a/Robust/src/IR/Tree/CastNode.java b/Robust/src/IR/Tree/CastNode.java
new file mode 100644 (file)
index 0000000..d9dc927
--- /dev/null
+++ b/Robust/src/IR/Tree/CastNode.java
@@ -0,0 +1,27 @@
+package IR.Tree;
+import IR.TypeDescriptor;
+
+public class CastNode extends ExpressionNode  {
+    TypeDescriptor td;
+    ExpressionNode etd;
+    ExpressionNode exp;
+
+    public CastNode(TypeDescriptor type, ExpressionNode exp) {
+       this.td=type;
+       this.exp=exp;
+       this.etd=null;
+    }
+
+    public CastNode(ExpressionNode type, ExpressionNode exp) {
+       this.td=null;
+       this.exp=exp;
+       this.etd=type;
+    }
+
+    public String printNode(int indentlevel) {
+       if (etd==null)
+           return "("+td.toString()+")"+exp.printNode(indentlevel);
+       else
+           return "("+etd.printNode(indentlevel)+")"+exp.printNode(indentlevel);
+    }
+}

diff --git a/Robust/src/IR/Tree/ClassNode.java b/Robust/src/IR/Tree/ClassNode.java
index 58e3f362f9a9a76f7e800304a801057977d7df67..d36dd969934ef46f8f63201b01976dbdec79d0ae 100644 (file)
--- a/Robust/src/IR/Tree/ClassNode.java
+++ b/Robust/src/IR/Tree/ClassNode.java
@@ -20,21 +20,24 @@ class ClassNode extends TreeNode {
     Vector methods;
     Hashtable methodmap;
     
-    public String printNode() {
+    public String printNode(int indent) {
        String st=modifiers.toString()+"class "+classname;
        if (superclass!=null) 
            st+="extends "+superclass.toString();
        st+=" {\n";
+       indent+=INDENT;
        for(int i=0;i<fields.size();i++) {
            FieldDescriptor fd=(FieldDescriptor)fields.get(i);
-           st+=fd.toString()+"\n";
+           st+=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+=md.toString()+"\n";
+           st+=printSpace(indent)+md.toString()+" ";
            BlockNode bn=(BlockNode)methodmap.get(md);
-           st+=bn.printNode();
+           st+=bn.printNode(indent)+"\n\n";
        }
        st+="}\n";
        return st;

diff --git a/Robust/src/IR/Tree/CreateObjectNode.java b/Robust/src/IR/Tree/CreateObjectNode.java
index e3a67db733381d1f7dedb7dd4a81245aa8becaba..3497e3dabf09e91d04424a039777e37c9de9077b 100644 (file)
--- a/Robust/src/IR/Tree/CreateObjectNode.java
+++ b/Robust/src/IR/Tree/CreateObjectNode.java
@@ -14,11 +14,11 @@ public class CreateObjectNode extends ExpressionNode {
        argumentlist.add(en);
     }
 
-    public String printNode() {
+    public String printNode(int indent) {
        String st="new "+td.toString()+"(";
        for(int i=0;i<argumentlist.size();i++) {
            ExpressionNode en=(ExpressionNode)argumentlist.get(i);
-           st+=en.printNode();
+           st+=en.printNode(indent);
            if ((i+1)!=argumentlist.size())
                st+=", ";
        }

diff --git a/Robust/src/IR/Tree/DeclarationNode.java b/Robust/src/IR/Tree/DeclarationNode.java
index 02b5d60546169b825631e0e1d20ab4e29d6bb7bd..75d1a165a2cd99d6d3b6071b4cded3c8d367c346 100644 (file)
--- a/Robust/src/IR/Tree/DeclarationNode.java
+++ b/Robust/src/IR/Tree/DeclarationNode.java
@@ -7,7 +7,7 @@ class DeclarationNode extends BlockStatementNode {
        vd=var;
     }
     
-    public String printNode() {
+    public String printNode(int indent) {
        return vd.toString();
     }
 

diff --git a/Robust/src/IR/Tree/ExpressionNode.java b/Robust/src/IR/Tree/ExpressionNode.java
index 609dea92c14bc5c067b69777730d7e895dfdae5b..058d629499305f214f8e2b99e18220b4fc8fef32 100644 (file)
--- a/Robust/src/IR/Tree/ExpressionNode.java
+++ b/Robust/src/IR/Tree/ExpressionNode.java
@@ -2,7 +2,7 @@ package IR.Tree;
 
 public class ExpressionNode extends TreeNode {
 
-    public String printNode() {
+    public String printNode(int indentlevel) {
        return null;
     }
 }

diff --git a/Robust/src/IR/Tree/FieldAccessNode.java b/Robust/src/IR/Tree/FieldAccessNode.java
index 960ce08cae9dbfe37af7eddbfb1de64fa42f8eb7..b2b953baaca31528ecc25d47ca1208a304b8b14c 100644 (file)
--- a/Robust/src/IR/Tree/FieldAccessNode.java
+++ b/Robust/src/IR/Tree/FieldAccessNode.java
@@ -9,7 +9,7 @@ public class FieldAccessNode extends ExpressionNode {
        left=l;
     }
 
-    public String printNode() {
-       return left.printNode()+"."+fieldname;
+    public String printNode(int indent) {
+       return left.printNode(indent)+"."+fieldname;
     }
 }

diff --git a/Robust/src/IR/Tree/FileNode.java b/Robust/src/IR/Tree/FileNode.java
index ddbf500d93e022f83b99988038c2a28f1cc3c9d3..c305822dbb762f2d80271d378872cadee2bd0b0d 100644 (file)
--- a/Robust/src/IR/Tree/FileNode.java
+++ b/Robust/src/IR/Tree/FileNode.java
@@ -12,11 +12,11 @@ class FileNode extends TreeNode {
        type_decls.add(tdn);
     }
 
-    public String printNode() {
+    public String printNode(int indent) {
        String st="";
        for(int i=0;i<type_decls.size();i++) {
            ClassNode cn=(ClassNode) type_decls.get(i);
-           st+=cn.printNode();
+           st+=cn.printNode(indent);
 
        }
        return st;

diff --git a/Robust/src/IR/Tree/IfStatementNode.java b/Robust/src/IR/Tree/IfStatementNode.java
index b161a1cd8952eedb1c87e42066b6a67deee40328..2dbf459e18b28ac51b005eb03a1aed2207e1f28c 100644 (file)
--- a/Robust/src/IR/Tree/IfStatementNode.java
+++ b/Robust/src/IR/Tree/IfStatementNode.java
@@ -11,11 +11,10 @@ class IfStatementNode extends BlockStatementNode {
        this.else_st=else_st;
     }
     
-    public String printNode() {
+    public String printNode(int indent) {
        if (else_st==null)
-           return "if("+cond.printNode()+") {\n"+true_st.printNode()+"\n}\n";
+           return "if("+cond.printNode(indent)+") "+true_st.printNode(indent);
        else 
-           return "if("+cond.printNode()+") {\n"+true_st.printNode()+"\n} else {\n"+
-               else_st.printNode()+"}\n";
+           return "if("+cond.printNode(indent)+") "+true_st.printNode(indent)+" else "+        else_st.printNode(indent);
     }
 }

diff --git a/Robust/src/IR/Tree/LiteralNode.java b/Robust/src/IR/Tree/LiteralNode.java
index 9bb3e672f023dfc4565fe9beafcb1c66a2300750..0997e6d3bbac985569ea2b162e5a659f6cd3c16b 100644 (file)
--- a/Robust/src/IR/Tree/LiteralNode.java
+++ b/Robust/src/IR/Tree/LiteralNode.java
@@ -50,9 +50,24 @@ public class LiteralNode extends ExpressionNode {
 
     }
 
-    public String printNode() {
+    public String printNode(int indent) {
        if (type==NULL)
            return "null";
+       if (type==STRING) {
+           return '"'+escapeString(value.toString())+'"';
+       }
        return "/*"+getType()+ "*/"+value.toString();
     }
+    private static String escapeString(String st) {
+       String new_st="";
+       for(int i=0;i<st.length();i++) {
+           char x=st.charAt(i);
+           if (x=='\n')
+               new_st+="\\n";
+           else if (x=='"')
+               new_st+="'"+'"'+"'";
+           else new_st+=x;
+       }
+       return new_st;
+    }
 }

diff --git a/Robust/src/IR/Tree/LoopNode.java b/Robust/src/IR/Tree/LoopNode.java
index 2dcba8c5b11fe369f900667709eeb8a1c915a3cf..baa86d010d2a7961b0c1524006db7fca8c30059c 100644 (file)
--- a/Robust/src/IR/Tree/LoopNode.java
+++ b/Robust/src/IR/Tree/LoopNode.java
@@ -1,11 +1,41 @@
 package IR.Tree;
 
 class LoopNode extends BlockStatementNode {
-    public SubBlockNode() {
+    BlockNode initializer;
+    ExpressionNode condition;
+    BlockNode update;
+    BlockNode body;
+    int type=0;
+    public static int FORLOOP=1;
+    public static int WHILELOOP=2;
+    public static int DOWHILELOOP=3;
+
+    public LoopNode(BlockNode initializer,ExpressionNode condition, BlockNode update, BlockNode body) {
+       this.initializer=initializer;
+       this.condition=condition;
+       this.update=update;
+       this.body=body;
+       initializer.setStyle(BlockNode.EXPRLIST);
+       update.setStyle(BlockNode.EXPRLIST);
+       type=FORLOOP;
+    }
+
+    public LoopNode(ExpressionNode condition, BlockNode body, int type) {
+       this.condition=condition;
+       this.body=body;
+       this.type=type;
     }
     
-    public String printNode() {
-       return null;
+    public String printNode(int indent) {
+       if (type==FORLOOP) {
+           return "for("+initializer.printNode(0)+";"+condition.printNode(0)+
+               ";"+update.printNode(0)+") "+body.printNode(indent)+"\n";
+       } else if (type==WHILELOOP) {
+           return "while("+condition.printNode(0)+") "+body.printNode(indent+INDENT)+"\n";
+       } else if (type==DOWHILELOOP) {
+           return "do "+ body.printNode(indent+INDENT)+
+               "while("+condition.printNode(0)+")\n";
+       } else throw new Error();
     }
 
 }

diff --git a/Robust/src/IR/Tree/MethodInvokeNode.java b/Robust/src/IR/Tree/MethodInvokeNode.java
index 51a7c5fd469d6231f8c926b2c297337ec22e5b40..a2888493c612f6cbf70a809e169045c7a59234cc 100644 (file)
--- a/Robust/src/IR/Tree/MethodInvokeNode.java
+++ b/Robust/src/IR/Tree/MethodInvokeNode.java
@@ -26,16 +26,16 @@ public class MethodInvokeNode extends ExpressionNode {
        argumentlist.add(en);
     }
 
-    public String printNode() {
+    public String printNode(int indent) {
        String st;
        if (nd==null) {
-           st=en.printNode()+"."+methodid+"(";
+           st=en.printNode(indent)+"."+methodid+"(";
        } else {
            st=nd.toString()+"(";
        }
        for(int i=0;i<argumentlist.size();i++) {
            ExpressionNode en=(ExpressionNode)argumentlist.get(i);
-           st+=en.printNode();
+           st+=en.printNode(indent);
            if ((i+1)!=argumentlist.size())
                st+=", ";
        }

diff --git a/Robust/src/IR/Tree/NameNode.java b/Robust/src/IR/Tree/NameNode.java
index be2f9864b4a41411e4976903fc8672af3a40e81f..26e5f5244323583dceb24894353b54f702200a43 100644 (file)
--- a/Robust/src/IR/Tree/NameNode.java
+++ b/Robust/src/IR/Tree/NameNode.java
@@ -7,7 +7,7 @@ public class NameNode extends ExpressionNode {
        this.name=nd;
     }
 
-    public String printNode() {
+    public String printNode(int indent) {
        return name.toString();
     }
 }

diff --git a/Robust/src/IR/Tree/OpNode.java b/Robust/src/IR/Tree/OpNode.java
index 2600024c0a4726f002cfbd8925c5bffb075ad224..3c370fd84a0497a5523193a5d5212b4ccd1e350e 100644 (file)
--- a/Robust/src/IR/Tree/OpNode.java
+++ b/Robust/src/IR/Tree/OpNode.java
@@ -18,10 +18,10 @@ public class OpNode extends ExpressionNode {
        op=o;
     }
 
-    public String printNode() {
+    public String printNode(int indent) {
        if (right==null)
-           return op.toString()+"("+left.printNode()+")";
+           return op.toString()+"("+left.printNode(indent)+")";
        else
-           return left.printNode()+" "+op.toString()+" "+right.printNode();
+           return left.printNode(indent)+" "+op.toString()+" "+right.printNode(indent);
     }
 }

diff --git a/Robust/src/IR/Tree/ReturnNode.java b/Robust/src/IR/Tree/ReturnNode.java
index 8499e52ab889fbc3f016af2432590494027dfb72..60ae5762d90eff54c0f3ca331b45f5ad9c1245ef 100644 (file)
--- a/Robust/src/IR/Tree/ReturnNode.java
+++ b/Robust/src/IR/Tree/ReturnNode.java
@@ -11,11 +11,11 @@ class ReturnNode extends BlockStatementNode {
        this.en=en;
     }
 
-    public String printNode() {
+    public String printNode(int indent) {
        if (en==null)
            return "return";
        else
-           return "return "+en.printNode();
+           return "return "+en.printNode(indent);
     }
 
 }

diff --git a/Robust/src/IR/Tree/SubBlockNode.java b/Robust/src/IR/Tree/SubBlockNode.java
index 85bdc1dd78894be6bf6134fa6d2602ed75c1c95f..2ad0beb1b358e08725ea83db3e6bf4b6bbc45988 100644 (file)
--- a/Robust/src/IR/Tree/SubBlockNode.java
+++ b/Robust/src/IR/Tree/SubBlockNode.java
@@ -6,8 +6,8 @@ class SubBlockNode extends BlockStatementNode {
        this.bn=bn;
     }
     
-    public String printNode() {
-       return bn.printNode();
+    public String printNode(int indent) {
+       return bn.printNode(indent);
     }
 
 }

diff --git a/Robust/src/IR/Tree/TreeNode.java b/Robust/src/IR/Tree/TreeNode.java
index 926022a178f162c7af01e91a8c0d426d4a9a25af..5aabe20c76c6e29a97ddf3d9c724238998872598 100644 (file)
--- a/Robust/src/IR/Tree/TreeNode.java
+++ b/Robust/src/IR/Tree/TreeNode.java
@@ -1,8 +1,15 @@
 package IR.Tree;
 
 class TreeNode {
+    public static final int INDENT=2;
 
-    public String printNode() {
+    public String printNode(int indent) {
        return null;
     }
+    public static String printSpace(int x) {
+       String sp="";
+       for(int i=0;i<x;i++)
+           sp+=" ";
+       return sp;
+    }
 }