From: bdemsky <bdemsky>
Date: Sun, 9 Apr 2006 08:23:32 +0000 (+0000)
Subject: Array support
X-Git-Tag: preEdgeChange~931
X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=76ce6dc60427aafd95e53c2188223072fac5f9a3;p=IRC.git

Array support
---

diff --git a/Robust/src/IR/ClassDescriptor.java b/Robust/src/IR/ClassDescriptor.java
index 73b66d7a..aae2e558 100644
--- a/Robust/src/IR/ClassDescriptor.java
+++ b/Robust/src/IR/ClassDescriptor.java
@@ -15,17 +15,7 @@ public class ClassDescriptor extends Descriptor {
 	methods=new SymbolTable();
 	classid=UIDCount++;
     }
-    private static int UIDCount=10; /* 0 is for Arrays */
-    /*    For element types we use as defined in TypeDescriptor
-	  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 BOOLEAN=6;
-	  public static final int FLOAT=7;
-	  public static final int DOUBLE=8;*/
-
+    private static int UIDCount=0; 
     private final int classid;
     String classname;
     String superclass;
diff --git a/Robust/src/IR/Flat/BuildCode.java b/Robust/src/IR/Flat/BuildCode.java
index 8dfb38d5..84d8eb4e 100644
--- a/Robust/src/IR/Flat/BuildCode.java
+++ b/Robust/src/IR/Flat/BuildCode.java
@@ -14,7 +14,7 @@ public class BuildCode {
     String paramsprefix="___params___";
     public static boolean GENERATEPRECISEGC=false;
     public static String PREFIX="";
-    public static String arraytype="___array___";
+    public static String arraytype="ArrayObject";
     Virtual virtualcalls;
     TypeUtil typeutil;
 
@@ -88,6 +88,7 @@ public class BuildCode {
 	outmethod.println("#include <runtime.h>");
 
 	outclassdefs.println("extern int classsize[];");
+	//Store the sizes of classes & array elements
 	generateSizeArray(outmethod);
 
 	Iterator classit=state.getClassSymbolTable().getDescriptorsIterator();
@@ -139,10 +140,10 @@ public class BuildCode {
 	}
 
 	ClassDescriptor objectcd=typeutil.getClass(TypeUtil.ObjectClass);
-	Iteratory arrait=state.getArrayIterator();
+	Iterator arrayit=state.getArrayIterator();
 	while(arrayit.hasNext()) {
 	    TypeDescriptor td=(TypeDescriptor)arrayit.next();
-	    int id=getArrayNumber(td);
+	    int id=state.getArrayNumber(td);
 	    fillinRow(objectcd, virtualtable, id+state.numClasses());
 	}
 	
@@ -195,6 +196,27 @@ public class BuildCode {
 	    outclassdefs.print("sizeof(struct "+cdarray[i].getSafeSymbol()+")");	    
 	    needcomma=true;
 	}
+
+	TypeDescriptor[] sizetable=new TypeDescriptor[state.numArrays()];
+
+	Iterator arrayit=state.getArrayIterator();
+	while(arrayit.hasNext()) {
+	    TypeDescriptor td=(TypeDescriptor)arrayit.next();
+	    int id=state.getArrayNumber(td);
+	    sizetable[id]=td;
+	}
+	
+	for(int i=0;i<state.numArrays();i++) {
+	    if (needcomma)
+		outclassdefs.print(", ");
+	    TypeDescriptor tdelement=sizetable[i].dereference();
+	    if (tdelement.isArray()||tdelement.isClass())
+		outclassdefs.print("sizeof(void *)");
+	    else
+		outclassdefs.print("sizeof("+tdelement.getSafeSymbol()+")");
+	    needcomma=true;
+	}
+
 	outclassdefs.println("};");
     }
 
@@ -247,7 +269,7 @@ public class BuildCode {
 
 	for(int i=0;i<fields.size();i++) {
 	    FieldDescriptor fd=(FieldDescriptor)fields.get(i);
-	    if (fd.getType().isClass())
+	    if (fd.getType().isClass()||fd.getType().isArray())
 		classdefout.println("  struct "+fd.getType().getSafeSymbol()+" * "+fd.getSafeSymbol()+";");
 	    else 
 		classdefout.println("  "+fd.getType().getSafeSymbol()+" "+fd.getSafeSymbol()+";");
@@ -301,7 +323,7 @@ public class BuildCode {
 	    
 	    /* Output method declaration */
 	    if (md.getReturnType()!=null) {
-		if (md.getReturnType().isClass())
+		if (md.getReturnType().isClass()||md.getReturnType().isArray())
 		    headersout.print("struct " + md.getReturnType().getSafeSymbol()+" * ");
 		else
 		    headersout.print(md.getReturnType().getSafeSymbol()+" ");
@@ -321,7 +343,7 @@ public class BuildCode {
 		if (printcomma)
 		    headersout.print(", ");
 		printcomma=true;
-		if (temp.getType().isClass())
+		if (temp.getType().isClass()||temp.getType().isArray())
 		    headersout.print("struct " + temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol());
 		else
 		    headersout.print(temp.getType().getSafeSymbol()+" "+temp.getSafeSymbol());
@@ -348,7 +370,7 @@ public class BuildCode {
 	    TypeDescriptor type=td.getType();
 	    if (type.isNull())
 		output.println("   void * "+td.getSafeSymbol()+";");
-	    else if (type.isClass())
+	    else if (type.isClass()||type.isArray())
 		output.println("   struct "+type.getSafeSymbol()+" * "+td.getSafeSymbol()+";");
 	    else
 		output.println("   "+type.getSafeSymbol()+" "+td.getSafeSymbol()+";");
@@ -453,6 +475,12 @@ public class BuildCode {
 	case FKind.FlatFieldNode:
 	    generateFlatFieldNode(fm, (FlatFieldNode) fn,output);
 	    return;
+	case FKind.FlatElementNode:
+	    generateFlatElementNode(fm, (FlatElementNode) fn,output);
+	    return;
+	case FKind.FlatSetElementNode:
+	    generateFlatSetElementNode(fm, (FlatSetElementNode) fn,output);
+	    return;
 	case FKind.FlatSetFieldNode:
 	    generateFlatSetFieldNode(fm, (FlatSetFieldNode) fn,output);
 	    return;
@@ -514,7 +542,7 @@ public class BuildCode {
 	} else {
 	    
 	    output.print("((");
-	    if (md.getReturnType().isClass())
+	    if (md.getReturnType().isClass()||md.getReturnType().isArray())
 		output.print("struct " + md.getReturnType().getSafeSymbol()+" * ");
 	    else
 		output.print(md.getReturnType().getSafeSymbol()+" ");
@@ -532,7 +560,7 @@ public class BuildCode {
 		if (printcomma)
 		    output.print(", ");
 		printcomma=true;
-		if (temp.getType().isClass())
+		if (temp.getType().isClass()||temp.getType().isArray())
 		    output.print("struct " + temp.getType().getSafeSymbol()+" * ");
 		else
 		    output.print(temp.getType().getSafeSymbol());
@@ -591,9 +619,34 @@ public class BuildCode {
 	output.println(generateTemp(fm, fsfn.getDst())+"->"+ fsfn.getField().getSafeSymbol()+"="+ generateTemp(fm,fsfn.getSrc())+";");
     }
 
+    private void generateFlatElementNode(FlatMethod fm, FlatElementNode fen, PrintWriter output) {
+	TypeDescriptor elementtype=fen.getSrc().getType().dereference();
+	String type="";
+
+	if (elementtype.isArray()||elementtype.isClass())
+	    type="void *";
+	else 
+	    type=elementtype.getSafeSymbol()+" ";
+	output.println(generateTemp(fm, fen.getDst())+"=(("+ type+"*)(((char *) &("+ generateTemp(fm,fen.getSrc())+"->length))+sizeof(int)))["+generateTemp(fm, fen.getIndex())+"];");
+    }
+
+    private void generateFlatSetElementNode(FlatMethod fm, FlatSetElementNode fsen, PrintWriter output) {
+	//TODO need dynamic check to make sure this assignment is actually legal
+	//Because Object[] could actually be something more specific...ie. Integer[]
+	TypeDescriptor elementtype=fsen.getDst().getType().dereference();
+	String type="";
+
+	if (elementtype.isArray()||elementtype.isClass())
+	    type="void *";
+	else 
+	    type=elementtype.getSafeSymbol()+" ";
+
+	output.println("(("+type +"*)(((char *) &("+ generateTemp(fm,fsen.getDst())+"->length))+sizeof(int)))["+generateTemp(fm, fsen.getIndex())+"]="+generateTemp(fm,fsen.getSrc())+";");
+    }
+
     private void generateFlatNew(FlatMethod fm, FlatNew fn, PrintWriter output) {
-	if (fm.getType().isArray()) {
-	    int arrayid=state.getArrayNumber(fm.getType())+state.numClasses();
+	if (fn.getType().isArray()) {
+	    int arrayid=state.getArrayNumber(fn.getType())+state.numClasses();
 	    output.println(generateTemp(fm,fn.getDst())+"=allocate_newarray("+arrayid+", "+generateTemp(fm, fn.getSize())+");");
 	} else
 	    output.println(generateTemp(fm,fn.getDst())+"=allocate_new("+fn.getType().getClassDesc().getId()+");");
@@ -657,7 +710,7 @@ public class BuildCode {
 	ClassDescriptor cn=md.getClassDesc();
 	
 	if (md.getReturnType()!=null) {
-	    if (md.getReturnType().isClass())
+	    if (md.getReturnType().isClass()||md.getReturnType().isArray())
 		output.print("struct " + md.getReturnType().getSafeSymbol()+" * ");
 	    else
 		output.print(md.getReturnType().getSafeSymbol()+" ");
@@ -678,7 +731,7 @@ public class BuildCode {
 	    if (printcomma)
 		output.print(", ");
 	    printcomma=true;
-	    if (temp.getType().isClass())
+	    if (temp.getType().isClass()||temp.getType().isArray())
 		output.print("struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol());
 	    else
 		output.print(temp.getType().getSafeSymbol()+" "+temp.getSafeSymbol());
diff --git a/Robust/src/IR/Flat/BuildFlat.java b/Robust/src/IR/Flat/BuildFlat.java
index 5b93dc64..9eaebf8d 100644
--- a/Robust/src/IR/Flat/BuildFlat.java
+++ b/Robust/src/IR/Flat/BuildFlat.java
@@ -123,9 +123,12 @@ public class BuildFlat {
 	    }
 	    FlatNew fn=new FlatNew(td, out_temp, temps[0]);
 	    last.addNext(fn);
-	    NodePair np=generateNewArrayLoop(temps, td.dereference(), out_temp, 0);
-	    fn.addNext(np.getBegin());
-	    return new NodePair(first,np.getEnd()); 
+	    if (temps.length>1) {
+		NodePair np=generateNewArrayLoop(temps, td.dereference(), out_temp, 0);
+		fn.addNext(np.getBegin());
+		return new NodePair(first,np.getEnd()); 
+	    } else
+		return new NodePair(first, fn);
 	}
     }
 
@@ -157,7 +160,7 @@ public class BuildFlat {
 	fcb.addFalseNext(fnop);
 	fn.addNext(fsen);
 	//Recursive call here
-	if ((i+1)<temparray.length) {
+	if ((i+2)<temparray.length) {
 	    NodePair np2=generateNewArrayLoop(temparray, td.dereference(), new_tmp, i+1);
 	    fsen.addNext(np2.getBegin());
 	    np2.getEnd().addNext(fon);
diff --git a/Robust/src/IR/State.java b/Robust/src/IR/State.java
index b8b43463..f70466cb 100644
--- a/Robust/src/IR/State.java
+++ b/Robust/src/IR/State.java
@@ -30,8 +30,10 @@ public class State {
     private int arraycount=0;
 
     public void addArrayType(TypeDescriptor td) {
-	arraytypes.add(td);
-	arraytonumber.put(td,new Integer(arraycount++));
+	if (!arraytypes.contains(td)) {
+	    arraytypes.add(td);
+	    arraytonumber.put(td,new Integer(arraycount++));
+	}
     }
 
     public Iterator getArrayIterator() {
diff --git a/Robust/src/IR/Tree/BuildIR.java b/Robust/src/IR/Tree/BuildIR.java
index 79026676..6a22ef7a 100644
--- a/Robust/src/IR/Tree/BuildIR.java
+++ b/Robust/src/IR/Tree/BuildIR.java
@@ -193,12 +193,13 @@ public class BuildIR {
 	    }
 	    return con;
 	} else if (isNode(pn,"createarray")) {
+	    System.out.println(pn.PPrint(3,true));
 	    TypeDescriptor td=parseTypeDescriptor(pn);
 	    Vector args=parseDimExprs(pn);
 	    int num=0;
 	    if (pn.getChild("dims_opt").getLiteral()!=null)
 		num=((Integer)pn.getChild("dims_opt").getLiteral()).intValue();
-	    for(int i=0;i<args.size()+num;i++)
+	    for(int i=0;i<(args.size()+num);i++)
 		td=td.makeArray(state);
 	    CreateObjectNode con=new CreateObjectNode(td);
 	    for(int i=0;i<args.size();i++) {
@@ -233,7 +234,7 @@ public class BuildIR {
 	    return new FieldAccessNode(en,fieldname);
 	} else if (isNode(pn,"arrayaccess")) { 
 	    ExpressionNode en=parseExpression(pn.getChild("base").getFirstChild());
-	    ExpressionNode index=parseExpression(pn.getChild("index"));
+	    ExpressionNode index=parseExpression(pn.getChild("index").getFirstChild());
 	    return new ArrayAccessNode(en,index);
 	} else if (isNode(pn,"cast1")) { 
 	    return new CastNode(parseTypeDescriptor(pn.getChild("type")),parseExpression(pn.getChild("exp").getFirstChild()));
diff --git a/Robust/src/IR/Tree/CreateObjectNode.java b/Robust/src/IR/Tree/CreateObjectNode.java
index d6dd2444..afeae5fb 100644
--- a/Robust/src/IR/Tree/CreateObjectNode.java
+++ b/Robust/src/IR/Tree/CreateObjectNode.java
@@ -38,14 +38,26 @@ public class CreateObjectNode extends ExpressionNode {
     }
 
     public String printNode(int indent) {
-	String st="new "+td.toString()+"(";
+	String st;
+	boolean isarray=td.isArray();
+	if (isarray)
+	    st="new "+td.toString()+"[";
+	else
+	    st="new "+td.toString()+"(";
 	for(int i=0;i<argumentlist.size();i++) {
 	    ExpressionNode en=(ExpressionNode)argumentlist.get(i);
 	    st+=en.printNode(indent);
-	    if ((i+1)!=argumentlist.size())
-		st+=", ";
+	    if ((i+1)!=argumentlist.size()) {
+		if (isarray) 
+		    st+="][";
+		else
+		    st+=", ";
+	    }
 	}
-	return st+")";
+	if (isarray)
+	    return st+"]";
+	else
+	    return st+")";
     }
 
     public int kind() {
diff --git a/Robust/src/IR/Tree/SemanticCheck.java b/Robust/src/IR/Tree/SemanticCheck.java
index 680603c0..da31b9d3 100644
--- a/Robust/src/IR/Tree/SemanticCheck.java
+++ b/Robust/src/IR/Tree/SemanticCheck.java
@@ -181,6 +181,9 @@ public class SemanticCheck {
         case Kind.FieldAccessNode:
 	    checkFieldAccessNode(md,nametable,(FieldAccessNode)en,td);
 	    return;
+        case Kind.ArrayAccessNode:
+	    checkArrayAccessNode(md,nametable,(ArrayAccessNode)en,td);
+	    return;
         case Kind.LiteralNode:
 	    checkLiteralNode(md,nametable,(LiteralNode)en,td);
 	    return;
@@ -244,6 +247,18 @@ public class SemanticCheck {
 		throw new Error("Field node returns "+fan.getType()+", but need "+td);
     }
 
+    void checkArrayAccessNode(MethodDescriptor md, SymbolTable nametable, ArrayAccessNode aan, TypeDescriptor td) {
+	ExpressionNode left=aan.getExpression();
+	checkExpressionNode(md,nametable,left,null);
+
+	checkExpressionNode(md,nametable,aan.getIndex(),new TypeDescriptor(TypeDescriptor.INT));
+	TypeDescriptor ltd=left.getType();
+
+	if (td!=null)
+	    if (!typeutil.isSuperorType(td,aan.getType()))
+		throw new Error("Field node returns "+aan.getType()+", but need "+td);
+    }
+
     void checkLiteralNode(MethodDescriptor md, SymbolTable nametable, LiteralNode ln, TypeDescriptor td) {
 	/* Resolve the type */
 	Object o=ln.getValue();
@@ -300,6 +315,7 @@ public class SemanticCheck {
 	checkExpressionNode(md, nametable, an.getSrc() ,td);
 	//TODO: Need check on validity of operation here
 	if (!((an.getDest() instanceof FieldAccessNode)||
+	      (an.getDest() instanceof ArrayAccessNode)||
 	      (an.getDest() instanceof NameNode)))
 	    throw new Error("Bad lside in "+an.printNode(0));
 	checkExpressionNode(md, nametable, an.getDest(), null);
@@ -339,43 +355,44 @@ public class SemanticCheck {
 
 	TypeDescriptor typetolookin=con.getType();
 	checkTypeDescriptor(typetolookin);
-	if (!typetolookin.isClass()) 
-	    throw new Error();
-
-	ClassDescriptor classtolookin=typetolookin.getClassDesc();
-	System.out.println("Looking for "+typetolookin.getSymbol());
-	System.out.println(classtolookin.getMethodTable());
-
-	Set methoddescriptorset=classtolookin.getMethodTable().getSet(typetolookin.getSymbol());
-	MethodDescriptor bestmd=null;
+	if ((!typetolookin.isClass())&&(!typetolookin.isArray())) 
+	    throw new Error("Can't allocate primitive type:"+con.printNode(0));
+
+	if (!typetolookin.isArray()) {
+	    //Array's don't need constructor calls
+	    ClassDescriptor classtolookin=typetolookin.getClassDesc();
+	    System.out.println("Looking for "+typetolookin.getSymbol());
+	    System.out.println(classtolookin.getMethodTable());
+	    
+	    Set methoddescriptorset=classtolookin.getMethodTable().getSet(typetolookin.getSymbol());
+	    MethodDescriptor bestmd=null;
 	NextMethod:
-	for(Iterator methodit=methoddescriptorset.iterator();methodit.hasNext();) {
-	    MethodDescriptor currmd=(MethodDescriptor)methodit.next();
-	    /* Need correct number of parameters */
-	    System.out.println("Examining: "+currmd);
-	    if (con.numArgs()!=currmd.numParameters())
-		continue;
-	    for(int i=0;i<con.numArgs();i++) {
-		if (!typeutil.isSuperorType(currmd.getParamType(i),tdarray[i]))
-		    continue NextMethod;
-	    }
-	    /* Method okay so far */
-	    if (bestmd==null)
-		bestmd=currmd;
-	    else {
-		if (isMoreSpecific(currmd,bestmd)) {
+	    for(Iterator methodit=methoddescriptorset.iterator();methodit.hasNext();) {
+		MethodDescriptor currmd=(MethodDescriptor)methodit.next();
+		/* Need correct number of parameters */
+		System.out.println("Examining: "+currmd);
+		if (con.numArgs()!=currmd.numParameters())
+		    continue;
+		for(int i=0;i<con.numArgs();i++) {
+		    if (!typeutil.isSuperorType(currmd.getParamType(i),tdarray[i]))
+			continue NextMethod;
+		}
+		/* Method okay so far */
+		if (bestmd==null)
 		    bestmd=currmd;
-		} else if (!isMoreSpecific(bestmd, currmd))
-		    throw new Error("No method is most specific");
-		
-		/* Is this more specific than bestmd */
+		else {
+		    if (isMoreSpecific(currmd,bestmd)) {
+			bestmd=currmd;
+		    } else if (!isMoreSpecific(bestmd, currmd))
+			throw new Error("No method is most specific");
+		    
+		    /* Is this more specific than bestmd */
+		}
 	    }
+	    if (bestmd==null)
+		throw new Error("No method found for "+con.printNode(0));
+	    con.setConstructor(bestmd);
 	}
-	if (bestmd==null)
-	    throw new Error("No method found for "+con.printNode(0));
-	con.setConstructor(bestmd);
-
-	
     }
 
 
diff --git a/Robust/src/IR/TypeDescriptor.java b/Robust/src/IR/TypeDescriptor.java
index 83276091..78270a0b 100644
--- a/Robust/src/IR/TypeDescriptor.java
+++ b/Robust/src/IR/TypeDescriptor.java
@@ -55,7 +55,11 @@ public class TypeDescriptor extends Descriptor {
     }
 
     public boolean isArray() {
-	return arraycount>0;
+	return (arraycount>0);
+    }
+
+    public int getArrayCount() {
+	return arraycount;
     }
 
     public TypeDescriptor dereference() {
@@ -69,7 +73,9 @@ public class TypeDescriptor extends Descriptor {
     }
 
     public String getSafeSymbol() {
-	if (isClass())
+	if (isArray()) 
+	    return IR.Flat.BuildCode.arraytype;
+	else if (isClass())
 	    return class_desc.getSafeSymbol();
 	else if (isByte())
 	    return "char";
diff --git a/Robust/src/IR/TypeUtil.java b/Robust/src/IR/TypeUtil.java
index fcf7a63e..5e12999a 100644
--- a/Robust/src/IR/TypeUtil.java
+++ b/Robust/src/IR/TypeUtil.java
@@ -59,6 +59,30 @@ public class TypeUtil {
     }
 
     public boolean isSuperorType(TypeDescriptor possiblesuper, TypeDescriptor cd2) {
+	//Matching type are always okay
+	if (possiblesuper.equals(cd2))
+	    return true;
+
+	//Handle arrays
+	if (cd2.isArray()||possiblesuper.isArray()) {
+	    // Object is super class of all arrays
+	    if (possiblesuper.getSymbol().equals(ObjectClass)&&!possiblesuper.isArray())
+		return true;
+
+	    // If we have the same dimensionality of arrays & both are classes, we can default to the normal test
+	    if (cd2.isClass()&&possiblesuper.isClass()
+		&&(possiblesuper.getArrayCount()==cd2.getArrayCount())&&
+		isSuperorType(possiblesuper.getClassDesc(), cd2.getClassDesc()))
+		return true;
+
+	    // Object is superclass of all array classes
+	    if (possiblesuper.getSymbol().equals(ObjectClass)&&cd2.isClass()
+		&&(possiblesuper.getArrayCount()<cd2.getArrayCount()))
+		return true;
+
+	    return false;
+	}
+
 	if (possiblesuper.isClass()&&
 	     cd2.isClass())
 	    return isSuperorType(possiblesuper.getClassDesc(), cd2.getClassDesc());
@@ -101,14 +125,14 @@ public class TypeUtil {
     }
 
 
-    public boolean isSuperorType(ClassDescriptor possiblesuper, ClassDescriptor cd2) {
+    private boolean isSuperorType(ClassDescriptor possiblesuper, ClassDescriptor cd2) {
 	if (possiblesuper==cd2)
 	    return true;
 	else
 	    return isSuper(possiblesuper, cd2);
     }
 
-    public boolean isSuper(ClassDescriptor possiblesuper, ClassDescriptor cd2) {
+    private boolean isSuper(ClassDescriptor possiblesuper, ClassDescriptor cd2) {
 	while(cd2!=null) {
 	    cd2=getSuper(cd2);
 	    if (cd2==possiblesuper)
diff --git a/Robust/src/Parse/java14.cup b/Robust/src/Parse/java14.cup
index 13000dc0..ec6c5b80 100644
--- a/Robust/src/Parse/java14.cup
+++ b/Robust/src/Parse/java14.cup
@@ -1068,8 +1068,8 @@ array_creation_uninit ::=
 //	;
 dim_exprs ::=	dim_expr:exp {: 
 		ParseNode pn=new ParseNode("dim_exprs");
-		pn.addChild("expr").addChild(exp);
-		RESULT=exp; :}
+		pn.addChild(exp);
+		RESULT=pn; :}
 	|	dim_exprs:base dim_expr:exp {: 
 		base.addChild(exp);
 		RESULT=base;
diff --git a/Robust/src/Runtime/runtime.c b/Robust/src/Runtime/runtime.c
index 05d94789..4a408c02 100644
--- a/Robust/src/Runtime/runtime.c
+++ b/Robust/src/Runtime/runtime.c
@@ -15,3 +15,10 @@ void * allocate_new(int type) {
   *((int *)v)=type;
   return v;
 }
+
+void * allocate_newarray(int type, int length) {
+  void * v=calloc(1,sizeof(struct ArrayObject)+length*classsize[type]);
+  ((int *)v)[0]=type;
+  ((int *)v)[1]=length;
+  return v;
+}
diff --git a/Robust/src/Runtime/runtime.h b/Robust/src/Runtime/runtime.h
index 3cd48e8f..8278de1d 100644
--- a/Robust/src/Runtime/runtime.h
+++ b/Robust/src/Runtime/runtime.h
@@ -5,5 +5,6 @@
 
 
 void * allocate_new(int type);
+void * allocate_newarray(int type, int length);
 
 #endif