From 748e9a88e0d20b9c2bad729669239ea0a8940a86 Mon Sep 17 00:00:00 2001
From: bdemsky <bdemsky>
Date: Fri, 10 Feb 2006 01:30:35 +0000
Subject: [PATCH] changes`

---
 Robust/src/IR/FieldDescriptor.java     | 14 ++++--
 Robust/src/IR/NameDescriptor.java      | 25 ++++++++++
 Robust/src/IR/State.java               |  8 ++++
 Robust/src/IR/Tree/BuildIR.java        | 65 +++++++++++++++++++++++---
 Robust/src/IR/Tree/ClassNode.java      |  5 +-
 Robust/src/IR/Tree/ExpressionNode.java |  8 ++++
 Robust/src/IR/TypeDescriptor.java      | 47 +++++++++++++++++--
 Robust/src/Parse/java14.cup            |  4 +-
 8 files changed, 160 insertions(+), 16 deletions(-)
 create mode 100644 Robust/src/IR/NameDescriptor.java
 create mode 100644 Robust/src/IR/Tree/ExpressionNode.java

diff --git a/Robust/src/IR/FieldDescriptor.java b/Robust/src/IR/FieldDescriptor.java
index 5375510c..367d44bd 100644
--- a/Robust/src/IR/FieldDescriptor.java
+++ b/Robust/src/IR/FieldDescriptor.java
@@ -1,5 +1,6 @@
 package IR;
 import IR.Tree.Modifiers;
+import IR.Tree.ExpressionNode;
 
 /**
  * Descriptor 
@@ -11,16 +12,23 @@ public class FieldDescriptor extends Descriptor {
 
     protected Modifiers modifier;
     protected TypeDescriptor td;
+    protected String identifier;
+    protected ExpressionNode en;
     
-    public FieldDescriptor(Modifiers m, TypeDescriptor t, String name) {
-	super(name);
+    public FieldDescriptor(Modifiers m, TypeDescriptor t, String identifier, ExpressionNode e) {
+	super(identifier);
 	this.modifier=m;
 	this.td=t;
+	this.identifier=identifier;
+	this.en=e;
         this.safename = "__" + name + "__";
 	this.uniqueid=count++;
     }
 
     public String toString() {
-	return modifier.toString()+";";
+	if (en==null)
+	    return modifier.toString()+td.toString()+" "+identifier+";";
+	else
+	    return modifier.toString()+td.toString()+" "+identifier+"="+en.toString()+";";
     }
 }
diff --git a/Robust/src/IR/NameDescriptor.java b/Robust/src/IR/NameDescriptor.java
new file mode 100644
index 00000000..65b3b64e
--- /dev/null
+++ b/Robust/src/IR/NameDescriptor.java
@@ -0,0 +1,25 @@
+package IR;
+
+public class NameDescriptor extends Descriptor {
+    String identifier;
+    NameDescriptor nd;
+    public NameDescriptor(NameDescriptor nd, String id) {
+	super(nd.toString()+"."+id);
+	identifier=id;
+	this.nd=nd;
+    }
+
+    public NameDescriptor(String id) {
+	super(id);
+	identifier=id;
+	nd=null;
+    }
+
+    public String toString() {
+	if (nd==null) 
+	    return identifier;
+	else
+	    return nd+"."+identifier;
+    }
+
+}
diff --git a/Robust/src/IR/State.java b/Robust/src/IR/State.java
index cb6c22d5..c6c34a1e 100644
--- a/Robust/src/IR/State.java
+++ b/Robust/src/IR/State.java
@@ -9,4 +9,12 @@ public class State {
     public SymbolTable globals;
     public ParseNode parsetree;
 
+    public static TypeDescriptor getTypeDescriptor(int t) {
+	TypeDescriptor td=new TypeDescriptor(t);
+	return td;
+    }
+    public static TypeDescriptor getTypeDescriptor(NameDescriptor n) {
+	TypeDescriptor td=new TypeDescriptor(n);
+	return td;
+    }
 }
diff --git a/Robust/src/IR/Tree/BuildIR.java b/Robust/src/IR/Tree/BuildIR.java
index 41594c4b..84ac2528 100644
--- a/Robust/src/IR/Tree/BuildIR.java
+++ b/Robust/src/IR/Tree/BuildIR.java
@@ -61,8 +61,7 @@ public class BuildIR {
 	ParseNode fieldnode=pn.getChild("field");
 
 	if (fieldnode!=null) {
-	    FieldDescriptor fd=parseFieldDecl(fieldnode.getChild("field_declaration"));
-	    cn.addField(fd);
+	    parseFieldDecl(cn,fieldnode.getChild("field_declaration"));
 	    return;
 	}
 	ParseNode methodnode=pn.getChild("method");
@@ -73,12 +72,68 @@ public class BuildIR {
 	throw new Error();
     }
 
-    private FieldDescriptor parseFieldDecl(ParseNode pn) {
+    private TypeDescriptor parseTypeDescriptor(ParseNode pn) {
+	ParseNode tn=pn.getChild("type");
+	String type_st=tn.getTerminal();
+	if(type_st.equals("byte")) {
+	    return state.getTypeDescriptor(TypeDescriptor.BYTE);
+	} else if(type_st.equals("short")) {
+	    return state.getTypeDescriptor(TypeDescriptor.SHORT);
+	} else if(type_st.equals("int")) {
+	    return state.getTypeDescriptor(TypeDescriptor.INT);
+	} else if(type_st.equals("long")) {
+	    return state.getTypeDescriptor(TypeDescriptor.LONG);
+	} else if(type_st.equals("char")) {
+	    return state.getTypeDescriptor(TypeDescriptor.CHAR);
+	} else if(type_st.equals("float")) {
+	    return state.getTypeDescriptor(TypeDescriptor.FLOAT);
+	} else if(type_st.equals("double")) {
+	    return state.getTypeDescriptor(TypeDescriptor.DOUBLE);
+	} else if(type_st.equals("class")) {
+	    ParseNode nn=tn.getChild("class");
+	    return state.getTypeDescriptor(parseName(nn));
+	} else
+	    throw new Error();
+    }
+
+    private NameDescriptor parseName(ParseNode pn) {
+	ParseNode nn=pn.getChild("name");
+	ParseNode base=nn.getChild("base");
+	ParseNode id=nn.getChild("identifier");
+	
+	if (base==null)
+	    return new NameDescriptor(id.getTerminal());
+
+	return new NameDescriptor(parseName(base),id.getTerminal());
+	
+    }
+
+    private void parseFieldDecl(ClassNode cn,ParseNode pn) {
 	ParseNode mn=pn.getChild("modifier");
 	Modifiers m=parseModifiersList(mn);
-	return new FieldDescriptor(m,null,null);
+	ParseNode tn=pn.getChild("type");
+	TypeDescriptor t=parseTypeDescriptor(tn);
+	ParseNode vn=pn.getChild("variables").getChild("variable_declarators_list");
+	ParseNodeVector pnv=vn.getChildren();
+	for(int i=0;i<pnv.size();i++) {
+	    ParseNode vardecl=pnv.elementAt(i);
+	    String identifier=vardecl.getChild("identifier").getChild("single").getTerminal();
+	    ParseNode epn=vardecl.getChild("initializer");
+	    
+	    ExpressionNode en=null;
+	    if (epn!=null)
+		en=parseExpression(epn);
+  
+	    cn.addField(new FieldDescriptor(m,t,identifier, en));
+	}
+	
+    }
+
+    private ExpressionNode parseExpression(ParseNode pn) {
+	return null;
     }
 
+
     private void parseMethodDecl(ClassNode cn, ParseNode pn) {
 	
     }
@@ -126,7 +181,6 @@ public class BuildIR {
 	else
 	    return false;
     }
-	
 
     /** Throw an exception if something is unexpected */
     private void check(ParseNode pn, String label) {
@@ -137,5 +191,4 @@ public class BuildIR {
             throw new Error(pn+ "IE: Expected '" + label + "', got '"+pn.getLabel()+"'");
         }
     }
-
 }
diff --git a/Robust/src/IR/Tree/ClassNode.java b/Robust/src/IR/Tree/ClassNode.java
index 8c35d45f..1392fc05 100644
--- a/Robust/src/IR/Tree/ClassNode.java
+++ b/Robust/src/IR/Tree/ClassNode.java
@@ -1,6 +1,7 @@
 package IR.Tree;
 import java.util.Vector;
 import IR.FieldDescriptor;
+import IR.NameDescriptor;
 
 class ClassNode extends TreeNode {
     ClassNode() {
@@ -9,7 +10,7 @@ class ClassNode extends TreeNode {
 	fields=new Vector();
     }
     String classname;
-    Name superclass;
+    NameDescriptor superclass;
     Modifiers modifiers;
     Vector fields;
     
@@ -36,7 +37,7 @@ class ClassNode extends TreeNode {
     void setName(String name) {
 	classname=name;
     }
-    void setSuper(Name superclass) {
+    void setSuper(NameDescriptor superclass) {
 	this.superclass=superclass;
     }
 }
diff --git a/Robust/src/IR/Tree/ExpressionNode.java b/Robust/src/IR/Tree/ExpressionNode.java
new file mode 100644
index 00000000..609dea92
--- /dev/null
+++ b/Robust/src/IR/Tree/ExpressionNode.java
@@ -0,0 +1,8 @@
+package IR.Tree;
+
+public class ExpressionNode extends TreeNode {
+
+    public String printNode() {
+	return null;
+    }
+}
diff --git a/Robust/src/IR/TypeDescriptor.java b/Robust/src/IR/TypeDescriptor.java
index 22e2e326..bd27c44d 100644
--- a/Robust/src/IR/TypeDescriptor.java
+++ b/Robust/src/IR/TypeDescriptor.java
@@ -7,10 +7,51 @@ package IR;
  */
 
 public class TypeDescriptor extends Descriptor {
+    public static final int BYTE=1;
+    public static final int SHORT=2;
+    public static final int INT=3;
+    public static final int LONG=4;
+    public static final int CHAR=5;
+    public static final int FLOAT=6;
+    public static final int DOUBLE=7;
+    public static final int CLASS=8;
+
+    int type;
+    NameDescriptor name_desc;
     
-    public TypeDescriptor(String name) {
-	super(name);
+    public TypeDescriptor(NameDescriptor name) {
+	super(name.toString());
+	this.type=CLASS;
+	this.name_desc=name;
     }
 
-    
+    public TypeDescriptor(int t) {
+	super(decodeInt(t));
+	this.type=t;
+    }
+
+    public String toString() {
+	if (type==CLASS)
+	    return name_desc.toString();
+	else 
+	    return decodeInt(type);
+    }
+
+    private static String decodeInt(int type) {
+	if (type==BYTE)
+	    return "byte";
+	else if (type==SHORT)
+	    return "short";
+	else if (type==INT)
+	    return "int";
+	else if (type==LONG)
+	    return "long";
+	else if (type==CHAR)
+	    return "char";
+	else if (type==FLOAT)
+	    return "float";
+	else if (type==DOUBLE)
+	    return "double";
+	else throw new Error();
+    }
 }
diff --git a/Robust/src/Parse/java14.cup b/Robust/src/Parse/java14.cup
index c6c34bc8..294ba59b 100644
--- a/Robust/src/Parse/java14.cup
+++ b/Robust/src/Parse/java14.cup
@@ -525,9 +525,9 @@ variable_declarator ::=
 	;
 variable_declarator_id ::=
 		IDENTIFIER:id {: 
-		RESULT=(new ParseNode("variable_declarator_id")).addChild("name").addChild(id);:}
+		RESULT=(new ParseNode("single")).addChild(id).getRoot();:}
 //	|	variable_declarator_id:id LBRACK RBRACK {:
-//		RESULT=(new ParseNode("variable_declarator_id")).addChild("array").addChild(id);:}
+//		RESULT=(new ParseNode("array")).addChild(id).getRoot();:}
 	;
 variable_initializer ::=
 		expression:exp {: RESULT=exp; :}
-- 
2.34.1