A start for array initializers. THIS IS NOT A WORKING IMPLEMENTATION\! I checked...

diff --git a/Robust/src/IR/Flat/BuildFlat.java b/Robust/src/IR/Flat/BuildFlat.java
index f964dd123638976c7d4ccd8352c9496f80acee0b..df775be2fd95354f0b24da6b8c025b2c7e1f0dea 100644 (file)
--- 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 (file)
index 0000000..d7fb399
--- /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 86a9c1dbdb85fd12aa3c1cdac9026de65cee317c..320f666379fdaf7013d7b78431c9f7c7af9cb809 100644 (file)
--- 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 7b93997a96c25e9ff73d016c624fa7b0e79731d7..a50a67f60698d44f59f1f572ddf1b5aa076688e0 100644 (file)
--- 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 815cef2798f560c7a787ac929f8020b924d3788f..d77cdb6f98e4cee2060e24b8c30253620278f781 100644 (file)
--- 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 6f6c2f3108e0a563470f57a1f8ce7209bafcfb1d..299a5e9b21a505456f398cfaefa7ba01db2e8073 100644 (file)
--- 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 (file)
index 0000000..540551e
--- /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