From: bdemsky <bdemsky>
Date: Wed, 15 Feb 2006 21:04:05 +0000 (+0000)
Subject: Other changes
X-Git-Tag: preEdgeChange~981
X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=320d9967eb9b0064b9a9bbb8718690884768889a;p=IRC.git

Other changes
---

diff --git a/Robust/src/IR/Tree/AssignmentNode.java b/Robust/src/IR/Tree/AssignmentNode.java
index d2d6082a..7829b41f 100644
--- 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 75824b11..ca725cff 100644
--- 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 b7d87196..6851ea89 100644
--- 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 001b9b5d..23f9a03c 100644
--- 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 a4f7c5b6..68bc9acc 100644
--- 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
index 00000000..d9dc9276
--- /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 58e3f362..d36dd969 100644
--- 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 e3a67db7..3497e3da 100644
--- 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 02b5d605..75d1a165 100644
--- 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 609dea92..058d6294 100644
--- 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 960ce08c..b2b953ba 100644
--- 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 ddbf500d..c305822d 100644
--- 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 b161a1cd..2dbf459e 100644
--- 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 9bb3e672..0997e6d3 100644
--- 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 2dcba8c5..baa86d01 100644
--- 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 51a7c5fd..a2888493 100644
--- 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 be2f9864..26e5f524 100644
--- 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 2600024c..3c370fd8 100644
--- 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 8499e52a..60ae5762 100644
--- 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 85bdc1dd..2ad0beb1 100644
--- 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 926022a1..5aabe20c 100644
--- 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;
+    }
 }