From fef1c1937bb59847b3be3820dcf65c51ea6c0213 Mon Sep 17 00:00:00 2001
From: jjenista <jjenista>
Date: Thu, 19 Feb 2009 19:28:20 +0000
Subject: [PATCH] A start for array initializers.  THIS IS NOT A WORKING
 IMPLEMENTATION\!  I checked in a short circuit to bomb out in BuildIR.java
 until I have time to go back and finish it.

---
 Robust/src/IR/Flat/BuildFlat.java            | 43 ++++++++++++++++++++
 Robust/src/IR/Tree/ArrayInitializerNode.java | 42 +++++++++++++++++++
 Robust/src/IR/Tree/BuildIR.java              | 18 ++++++++
 Robust/src/IR/Tree/Kind.java                 |  1 +
 Robust/src/IR/Tree/SemanticCheck.java        |  9 ++++
 Robust/src/Parse/java14.cup                  | 41 +++++++++++++------
 Robust/src/Tests/ArrayInitializerTest.java   |  8 ++++
 7 files changed, 149 insertions(+), 13 deletions(-)
 create mode 100644 Robust/src/IR/Tree/ArrayInitializerNode.java
 create mode 100644 Robust/src/Tests/ArrayInitializerTest.java

diff --git a/Robust/src/IR/Flat/BuildFlat.java b/Robust/src/IR/Flat/BuildFlat.java
index f964dd12..df775be2 100644
--- a/Robust/src/IR/Flat/BuildFlat.java
+++ b/Robust/src/IR/Flat/BuildFlat.java
@@ -792,6 +792,9 @@ public class BuildFlat {
 
     case Kind.InstanceOfNode:
       return flattenInstanceOfNode((InstanceOfNode)en,out_temp);
+
+    case Kind.ArrayInitializerNode:
+      return flattenArrayInitializerNode((ArrayInitializerNode)en,out_temp);
     }
     throw new Error();
   }
@@ -1090,6 +1093,46 @@ public class BuildFlat {
     return new NodePair(cond.getBegin(),fion);
   }
 
+  private NodePair flattenArrayInitializerNode(ArrayInitializerNode ain, TempDescriptor out_temp) {
+    /*
+    TempDescriptor expr_temp=TempDescriptor.tempFactory("arry_init",ain.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;
+  }
+
   private NodePair flattenTertiaryNode(TertiaryNode tn, TempDescriptor out_temp) {
     TempDescriptor cond_temp=TempDescriptor.tempFactory("tert_cond",new TypeDescriptor(TypeDescriptor.BOOLEAN));
     TempDescriptor true_temp=TempDescriptor.tempFactory("tert_true",tn.getTrueExpr().getType());
diff --git a/Robust/src/IR/Tree/ArrayInitializerNode.java b/Robust/src/IR/Tree/ArrayInitializerNode.java
new file mode 100644
index 00000000..d7fb3993
--- /dev/null
+++ b/Robust/src/IR/Tree/ArrayInitializerNode.java
@@ -0,0 +1,42 @@
+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;
+    varInitList=vil;
+  }
+
+  public TypeDescriptor getType() {
+    return td;
+  }
+
+  public int numVarInitializers() {
+    return varInitList.size();
+  }
+
+  public ExpressionNode getVarInitializer(int i) {
+    return (ExpressionNode) varInitList.get(i);
+  }
+
+  public String printNode(int indent) {
+    String st="{";
+    for(int i=0; i<varInitList.size(); i++) {
+      ExpressionNode en=(ExpressionNode)varInitList.get(i);
+      st+=en.printNode(indent);
+      if ((i+1)!=varInitList.size()) {
+	st+=", ";
+      }
+    }
+    return st+"}";
+  }
+
+  public int kind() {
+    return Kind.ArrayInitializerNode;
+  }
+}
diff --git a/Robust/src/IR/Tree/BuildIR.java b/Robust/src/IR/Tree/BuildIR.java
index 86a9c1db..320f6663 100644
--- a/Robust/src/IR/Tree/BuildIR.java
+++ b/Robust/src/IR/Tree/BuildIR.java
@@ -493,6 +493,12 @@ 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." );
+      System.exit( -1 );
+      TypeDescriptor td=parseTypeDescriptor(pn);      
+      Vector initializers=parseVariableInitializerList(pn);
+      return new ArrayInitializerNode(td, initializers);
     } else {
       System.out.println("---------------------");
       System.out.println(pn.PPrint(3,true));
@@ -541,6 +547,18 @@ public class BuildIR {
     return new Vector[] {varlist, arglist};
   }
 
+  private Vector parseVariableInitializerList(ParseNode pn) {
+    Vector varInitList=new Vector();
+    ParseNode vin=pn.getChild("variable_init_list");
+    if (vin==null)       /* No argument list */
+      return varInitList;
+    ParseNodeVector vinv=vin.getChildren();
+    for(int i=0; i<vinv.size(); i++) {
+      varInitList.add(parseExpression(vinv.elementAt(i)));
+    }
+    return varInitList;
+  }
+
   private ExpressionNode parseAssignmentExpression(ParseNode pn) {
     AssignOperation ao=new AssignOperation(pn.getChild("op").getTerminal());
     ParseNodeVector pnv=pn.getChild("args").getChildren();
diff --git a/Robust/src/IR/Tree/Kind.java b/Robust/src/IR/Tree/Kind.java
index 7b93997a..a50a67f6 100644
--- a/Robust/src/IR/Tree/Kind.java
+++ b/Robust/src/IR/Tree/Kind.java
@@ -27,4 +27,5 @@ public class Kind {
   public final static int ContinueBreakNode=24;
   public final static int TertiaryNode=25;
   public final static int InstanceOfNode=26;
+  public final static int ArrayInitializerNode=27;
 }
diff --git a/Robust/src/IR/Tree/SemanticCheck.java b/Robust/src/IR/Tree/SemanticCheck.java
index 815cef27..d77cdb6f 100644
--- a/Robust/src/IR/Tree/SemanticCheck.java
+++ b/Robust/src/IR/Tree/SemanticCheck.java
@@ -418,6 +418,10 @@ public class SemanticCheck {
     case Kind.InstanceOfNode:
       checkInstanceOfNode(md, nametable, (InstanceOfNode) en, td);
       return;
+
+    case Kind.ArrayInitializerNode:
+      checkArrayInitializerNode(md, nametable, (ArrayInitializerNode) en, td);
+      return;
     }
     throw new Error();
   }
@@ -584,6 +588,11 @@ public class SemanticCheck {
     checkExpressionNode(md, nametable, tn.getExpr(), null);
   }
 
+  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); 
+    }
+  }
 
   void checkAssignmentNode(Descriptor md, SymbolTable nametable, AssignmentNode an, TypeDescriptor td) {
     boolean postinc=true;
diff --git a/Robust/src/Parse/java14.cup b/Robust/src/Parse/java14.cup
index 6f6c2f31..299a5e9b 100644
--- a/Robust/src/Parse/java14.cup
+++ b/Robust/src/Parse/java14.cup
@@ -161,8 +161,8 @@ non terminal ParseNode explicit_constructor_invocation;
 //non terminal ParseNode interface_member_declaration, constant_declaration;
 //non terminal ParseNode abstract_method_declaration;
 // 19.10) Arrays
-//non terminal ParseNode array_initializer;
-//non terminal ParseNode variable_initializers;
+non terminal ParseNode array_initializer;
+non terminal ParseNode variable_initializers;
 // 19.11) Blocks and Statements
 non terminal ParseNode block;
 non terminal ParseNode block_statements_opt, block_statements, block_statement;
@@ -870,7 +870,7 @@ variable_declarator_id ::=
 	;
 variable_initializer ::=
 		expression:exp {: RESULT=exp; :}
-//	|	array_initializer
+	|	array_initializer {: RESULT=new ParseNode("array_initializer"); :}
 	;
 
 // 19.8.3) Method Declarations
@@ -1070,16 +1070,31 @@ SUPER LPAREN argument_list_opt:alo RPAREN SEMICOLON {:
 
 
 // 19.10) Arrays
-//array_initializer ::=
-//		LBRACE variable_initializers COMMA RBRACE
-//	|	LBRACE variable_initializers RBRACE
-//	|	LBRACE COMMA RBRACE
-//	|	LBRACE RBRACE
-//	;
-//variable_initializers ::=
-//		variable_initializer
-//	|	variable_initializers COMMA variable_initializer
-//	;
+array_initializer ::=
+		LBRACE variable_initializers:var_init_list COMMA RBRACE {:
+		       RESULT=var_init_list;
+		:}
+	|	LBRACE variable_initializers:var_init_list RBRACE {:
+		       RESULT=var_init_list;
+		:}
+	|	LBRACE COMMA RBRACE {:
+		       RESULT=new ParseNode("empty");		       
+		:}
+	|	LBRACE RBRACE {:
+		       RESULT=new ParseNode("empty");
+		:}
+	;
+variable_initializers ::=
+		variable_initializer:var_init {:
+		       ParseNode pn=new ParseNode("var_init_list");
+		       pn.addChild(var_init);
+		       RESULT=pn;
+		:}
+	|	variable_initializers:var_init_list COMMA variable_initializer:var_init {:
+		       var_init_list.addChild(var_init);
+		       RESULT=var_init_list;
+		:}
+	;
 
 // 19.11) Blocks and Statements
 block ::=	LBRACE block_statements_opt:bso RBRACE {: 
diff --git a/Robust/src/Tests/ArrayInitializerTest.java b/Robust/src/Tests/ArrayInitializerTest.java
new file mode 100644
index 00000000..540551e9
--- /dev/null
+++ b/Robust/src/Tests/ArrayInitializerTest.java
@@ -0,0 +1,8 @@
+public class ArrayInitializerTest {
+  static public void main( String[] args ) {
+    
+    int[] a = { 1, 2, 3 };
+
+    System.out.println( "a[2] should be 3: "+a[2] );
+  }
+}
\ No newline at end of file
-- 
2.34.1