From d28b89d96693de8e64ddc490902d4be956d032d0 Mon Sep 17 00:00:00 2001
From: jzhou <jzhou>
Date: Thu, 27 Jan 2011 00:51:49 +0000
Subject: [PATCH] Basic implementation of array initialization for mgc: local
 array declaration with array initialization is OK now. Need more work to
 enable array field declaration with initialization and array creation with
 initialization. Also fix a bug: previously do not support static fields that
 are object/array.

---
 Robust/src/IR/Flat/BuildCode.java            | 20 +++++-
 Robust/src/IR/Flat/BuildFlat.java            | 71 ++++++++++----------
 Robust/src/IR/Tree/ArrayInitializerNode.java | 10 +--
 Robust/src/IR/Tree/BuildIR.java              | 17 +++--
 Robust/src/IR/Tree/CreateObjectNode.java     | 20 +++++-
 Robust/src/IR/Tree/SemanticCheck.java        |  2 +-
 Robust/src/Tests/ArrayInitializerTest.java   | 11 +++
 7 files changed, 93 insertions(+), 58 deletions(-)

diff --git a/Robust/src/IR/Flat/BuildCode.java b/Robust/src/IR/Flat/BuildCode.java
index 2fb5e3bf..dffb65c9 100644
--- a/Robust/src/IR/Flat/BuildCode.java
+++ b/Robust/src/IR/Flat/BuildCode.java
@@ -1621,9 +1621,25 @@ public class BuildCode {
       if (state.MGC && fd.getType().isClass()
           && fd.getType().getClassDesc().isEnum()) {
         classdefout.println("  int " + fd.getSafeSymbol() + ";");
-      } else if (fd.getType().isClass()||fd.getType().isArray())
+      } else if (fd.getType().isClass()||fd.getType().isArray()) {
+        if ((state.MGC) && (fd.isStatic())) {
+          // TODO add version for normal Java later
+          // static field
+          if(fd.isVolatile()) {
+            globaldefout.println("  volatile struct "+fd.getType().getSafeSymbol()+ " * "+cn.getSafeSymbol()+fd.getSafeSymbol()+";");
+          } else {
+            globaldefout.println("  struct "+fd.getType().getSafeSymbol()+ " * "+cn.getSafeSymbol()+fd.getSafeSymbol()+";");
+          }
+          classdefout.println("  struct "+fd.getType().getSafeSymbol()+" ** "+fd.getSafeSymbol()+";");
+        } else if ((state.MGC) && (fd.isVolatile())) {
+          // TODO add version for normal Java later
+          // static field
+          globaldefout.println("  volatile struct "+fd.getType().getSafeSymbol()+ " * "+cn.getSafeSymbol()+fd.getSafeSymbol()+";");
+          classdefout.println("  struct"+fd.getType().getSafeSymbol()+" ** "+fd.getSafeSymbol()+";");
+        } else {
 	classdefout.println("  struct "+fd.getType().getSafeSymbol()+" * "+fd.getSafeSymbol()+";");
-      else if ((state.MGC) && (fd.isStatic())) {
+        }
+      } else if ((state.MGC) && (fd.isStatic())) {
         // TODO add version for normal Java later
         // static field
         if(fd.isVolatile()) {
diff --git a/Robust/src/IR/Flat/BuildFlat.java b/Robust/src/IR/Flat/BuildFlat.java
index 97b697b7..f5347897 100644
--- a/Robust/src/IR/Flat/BuildFlat.java
+++ b/Robust/src/IR/Flat/BuildFlat.java
@@ -1387,43 +1387,44 @@ public class BuildFlat {
   }
 
   private NodePair flattenArrayInitializerNode(ArrayInitializerNode ain, TempDescriptor out_temp) {
-    /*
-    TempDescriptor expr_temp=TempDescriptor.tempFactory("arry_init",ain.getType());
+    boolean isGlobal = false;
+    String disjointId = null;
+    // get the type the array to be initialized
+    TypeDescriptor td = out_temp.getType();
 
     // create a new array of size equal to the array initializer
-    //FlatNode first=null;
-    //FlatNode last=null;
-    TempDescriptor[] temps=new TempDescriptor[ain.numVarInitializers()];
-
-      for (int i=0; i<con.numArgs(); i++) {
-	ExpressionNode en=con.getArg(i);
-	TempDescriptor tmp=TempDescriptor.tempFactory("arg",en.getType());
-	temps[i]=tmp;
-	NodePair np=flattenExpressionNode(en, tmp);
-	if (first==null)
-	  first=np.getBegin();
-	else
-	  last.addNext(np.getBegin());
-	last=np.getEnd();
-
-	TempDescriptor tmp2=(i==0) ?
-	                     out_temp :
-	                     TempDescriptor.tempFactory("arg",en.getType());
-      }
-      FlatNew fn=new FlatNew(td, out_temp, temps[0], con.isGlobal(), con.getDisjointId());
-      last.addNext(fn);
-
-
-    // assign each element of the new array to the flattened expression
-
-
-    FlatOpNode fonAssignArray=new FlatOpNode(out_temp, newarry_temp, null, new Operation(Operation.ASSIGN));
-    */
-    //return new NodePair( , fonAssignArray );
-    ain.printNode(0);
-    System.out.println( "Array initializers not implemented yet." );
-    System.exit( -1 );
-    return null;
+    FlatNode first=null;
+    FlatNode last=null;
+    TempDescriptor tmp=TempDescriptor.tempFactory("arg", new TypeDescriptor(TypeDescriptor.INT));
+    FlatLiteralNode fln_tmp=new FlatLiteralNode(tmp.getType(), new Integer(ain.numVarInitializers()), tmp);
+    first = last=fln_tmp;
+    
+    // create the new array
+    FlatNew fn=new FlatNew(td, out_temp, tmp, isGlobal, disjointId);
+    last.addNext(fn);
+    last = fn;
+    
+    // initialize the new array
+    for(int i = 0; i < ain.numVarInitializers(); i++) {
+      ExpressionNode var_init_node = ain.getVarInitializer(i);
+      TempDescriptor tmp_toinit = out_temp;
+      TempDescriptor tmp_init=TempDescriptor.tempFactory("array_init", td.dereference());
+      // index=i
+      TempDescriptor index=TempDescriptor.tempFactory("index", new TypeDescriptor(TypeDescriptor.INT));
+      FlatLiteralNode fln=new FlatLiteralNode(index.getType(), new Integer(i), index);
+      // calculate the initial value
+      NodePair np_init = flattenExpressionNode(var_init_node, tmp_init);
+      // TODO wrapper class process is missing now
+      /*if(td.isArray() && td.dereference().iswrapper()) {
+      }*/
+      FlatSetElementNode fsen=new FlatSetElementNode(tmp_toinit, index, tmp_init);
+      last.addNext(fln);
+      fln.addNext(np_init.getBegin());
+      np_init.getEnd().addNext(fsen);
+      last = fsen;
+    }
+    
+    return new NodePair(first, last);
   }
 
   private NodePair flattenTertiaryNode(TertiaryNode tn, TempDescriptor out_temp) {
diff --git a/Robust/src/IR/Tree/ArrayInitializerNode.java b/Robust/src/IR/Tree/ArrayInitializerNode.java
index d7fb3993..48dab8a7 100644
--- a/Robust/src/IR/Tree/ArrayInitializerNode.java
+++ b/Robust/src/IR/Tree/ArrayInitializerNode.java
@@ -1,21 +1,13 @@
 package IR.Tree;
 import java.util.Vector;
-import IR.TypeDescriptor;
-import IR.MethodDescriptor;
 
 public class ArrayInitializerNode extends ExpressionNode {
-  TypeDescriptor td;
   Vector varInitList;
 
-  public ArrayInitializerNode(TypeDescriptor type, Vector vil) {
-    td=type;
+  public ArrayInitializerNode(Vector vil) {
     varInitList=vil;
   }
 
-  public TypeDescriptor getType() {
-    return td;
-  }
-
   public int numVarInitializers() {
     return varInitList.size();
   }
diff --git a/Robust/src/IR/Tree/BuildIR.java b/Robust/src/IR/Tree/BuildIR.java
index c0ee0ec6..b3bec386 100644
--- a/Robust/src/IR/Tree/BuildIR.java
+++ b/Robust/src/IR/Tree/BuildIR.java
@@ -745,7 +745,10 @@ public class BuildIR {
     td=td.makeArray(state);
       CreateObjectNode con=new CreateObjectNode(td, false, null);
       // TODO array initializers
-      pn.getChild("initializer");
+      ParseNode ipn = pn.getChild("initializer");     
+      Vector initializers=parseVariableInitializerList(ipn);
+      ArrayInitializerNode ain = new ArrayInitializerNode(initializers);
+      con.addArrayInitializer(ain);
       return con;
     } else if (isNode(pn,"name")) {
       NameDescriptor nd=parseName(pn);
@@ -804,13 +807,9 @@ public class BuildIR {
       ExpressionNode exp=parseExpression(pn.getChild("exp").getFirstChild());
       TypeDescriptor t=parseTypeDescriptor(pn);
       return new InstanceOfNode(exp,t);
-    } else if (isNode(pn, "array_initializer")) {
-      System.out.println( "Array initializers not implemented yet." );
-      return null; // TODO MGC
-      //throw new Error();
-      //TypeDescriptor td=parseTypeDescriptor(pn);      
-      //Vector initializers=parseVariableInitializerList(pn);
-      //return new ArrayInitializerNode(td, initializers);
+    } else if (isNode(pn, "array_initializer")) {  
+      Vector initializers=parseVariableInitializerList(pn);
+      return new ArrayInitializerNode(initializers);
     } else if (isNode(pn, "class_type") && state.MGC) {
       TypeDescriptor td=parseTypeDescriptor(pn);
       return new ClassTypeNode(td);
@@ -866,7 +865,7 @@ public class BuildIR {
 
   private Vector parseVariableInitializerList(ParseNode pn) {
     Vector varInitList=new Vector();
-    ParseNode vin=pn.getChild("variable_init_list");
+    ParseNode vin=pn.getChild("var_init_list");
     if (vin==null)       /* No argument list */
       return varInitList;
     ParseNodeVector vinv=vin.getChildren();
diff --git a/Robust/src/IR/Tree/CreateObjectNode.java b/Robust/src/IR/Tree/CreateObjectNode.java
index dd1d57ca..ccc5f3a2 100644
--- a/Robust/src/IR/Tree/CreateObjectNode.java
+++ b/Robust/src/IR/Tree/CreateObjectNode.java
@@ -10,12 +10,14 @@ public class CreateObjectNode extends ExpressionNode {
   FlagEffects fe;
   boolean isglobal;
   String disjointId;
+  ArrayInitializerNode ain;
 
   public CreateObjectNode(TypeDescriptor type, boolean isglobal, String disjointId) {
     td=type;
     argumentlist=new Vector();
     this.isglobal=isglobal;
     this.disjointId=disjointId;
+    this.ain = null;
   }
 
   public boolean isGlobal() {
@@ -57,6 +59,14 @@ public class CreateObjectNode extends ExpressionNode {
   public ExpressionNode getArg(int i) {
     return (ExpressionNode) argumentlist.get(i);
   }
+  
+  public void addArrayInitializer(ArrayInitializerNode ain) {
+   this.ain = ain; 
+  }
+  
+  public ArrayInitializerNode getArrayInitializer() {
+    return this.ain;
+  }
 
   public String printNode(int indent) {
     String st;
@@ -76,9 +86,15 @@ public class CreateObjectNode extends ExpressionNode {
       }
     }
     if (isarray)
-      return st+"]";
+      st += "]";
     else
-      return st+")";
+      st += ")";
+    if(isarray && this.ain != null) {
+      st += "{";
+      st += this.ain.printNode(indent);
+      st += "}";
+    }
+    return st;
   }
 
   public int kind() {
diff --git a/Robust/src/IR/Tree/SemanticCheck.java b/Robust/src/IR/Tree/SemanticCheck.java
index 401b0052..4feeb962 100644
--- a/Robust/src/IR/Tree/SemanticCheck.java
+++ b/Robust/src/IR/Tree/SemanticCheck.java
@@ -774,7 +774,7 @@ public class SemanticCheck {
 
   void checkArrayInitializerNode(Descriptor md, SymbolTable nametable, ArrayInitializerNode ain, TypeDescriptor td) {
     for( int i = 0; i < ain.numVarInitializers(); ++i ) {
-      checkExpressionNode(md, nametable, ain.getVarInitializer(i), td); 
+      checkExpressionNode(md, nametable, ain.getVarInitializer(i), td.dereference()); 
     }
   }
 
diff --git a/Robust/src/Tests/ArrayInitializerTest.java b/Robust/src/Tests/ArrayInitializerTest.java
index 540551e9..486be9c9 100644
--- a/Robust/src/Tests/ArrayInitializerTest.java
+++ b/Robust/src/Tests/ArrayInitializerTest.java
@@ -4,5 +4,16 @@ public class ArrayInitializerTest {
     int[] a = { 1, 2, 3 };
 
     System.out.println( "a[2] should be 3: "+a[2] );
+    
+    int ia[][] = { {1, 2}, null };
+    for (int i = 0; i < 2; i++) {
+      if(ia[i] != null) {
+        for (int j = 0; j < 2; j++) {
+            System.out.println(ia[i][j]);
+        }
+      } else {
+        System.out.println("ia[" + i + "] is null");
+      }
+    }
   }
 }
\ No newline at end of file
-- 
2.34.1