1) Moved net.sourceforge.phpeclipse.ui\src\net\sourceforge\phpdt back to net.sourcefo...
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / compiler / ast / ArrayAllocationExpression.java
index 28b5d97..3d8c880 100644 (file)
@@ -1,17 +1,16 @@
 /*******************************************************************************
- * Copyright (c) 2000, 2001, 2002 International Business Machines Corp. and others.
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Common Public License v0.5 
+ * are made available under the terms of the Common Public License v1.0
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/cpl-v05.html
+ * http://www.eclipse.org/legal/cpl-v10.html
  * 
  * Contributors:
  *     IBM Corporation - initial API and implementation
- ******************************************************************************/
+ *******************************************************************************/
 package net.sourceforge.phpdt.internal.compiler.ast;
 
-import net.sourceforge.phpdt.internal.compiler.IAbstractSyntaxTreeVisitor;
-import net.sourceforge.phpdt.internal.compiler.codegen.CodeStream;
+import net.sourceforge.phpdt.internal.compiler.ASTVisitor;
 import net.sourceforge.phpdt.internal.compiler.flow.FlowContext;
 import net.sourceforge.phpdt.internal.compiler.flow.FlowInfo;
 import net.sourceforge.phpdt.internal.compiler.impl.Constant;
@@ -23,12 +22,11 @@ public class ArrayAllocationExpression extends Expression {
 
        public TypeReference type;
 
-       //dimensions.length gives the number of dimensions, but the
+       // dimensions.length gives the number of dimensions, but the
        // last ones may be nulled as in new int[4][5][][]
        public Expression[] dimensions;
-       public ArrayInitializer initializer;
 
-       public ArrayBinding arrayTb;
+       public ArrayInitializer initializer;
 
        /**
         * ArrayAllocationExpression constructor comment.
@@ -37,10 +35,8 @@ public class ArrayAllocationExpression extends Expression {
                super();
        }
 
-       public FlowInfo analyseCode(
-               BlockScope currentScope,
-               FlowContext flowContext,
-               FlowInfo flowInfo) {
+       public FlowInfo analyseCode(BlockScope currentScope,
+                       FlowContext flowContext, FlowInfo flowInfo) {
                for (int i = 0, max = dimensions.length; i < max; i++) {
                        Expression dim;
                        if ((dim = dimensions[i]) != null) {
@@ -57,104 +53,128 @@ public class ArrayAllocationExpression extends Expression {
        /**
         * Code generation for a array allocation expression
         */
-       public void generateCode(
-               BlockScope currentScope,
-               CodeStream codeStream,
-               boolean valueRequired) {
-
-               int pc = codeStream.position;
-               ArrayBinding arrayBinding;
-
-               if (initializer != null) {
-                       initializer.generateCode(currentScope, codeStream, valueRequired);
-                       return;
-               }
-
-               int nonNullDimensionsLength = 0;
-               for (int i = 0, max = dimensions.length; i < max; i++)
-                       if (dimensions[i] != null) {
-                               dimensions[i].generateCode(currentScope, codeStream, true);
-                               nonNullDimensionsLength++;
+       // public void generateCode(
+       // BlockScope currentScope,
+       // CodeStream codeStream,
+       // boolean valueRequired) {
+       //
+       // int pc = codeStream.position;
+       //
+       // if (initializer != null) {
+       // initializer.generateCode(currentScope, codeStream, valueRequired);
+       // return;
+       // }
+       //
+       // int nonNullDimensionsLength = 0;
+       // for (int i = 0, max = dimensions.length; i < max; i++)
+       // if (dimensions[i] != null) {
+       // dimensions[i].generateCode(currentScope, codeStream, true);
+       // nonNullDimensionsLength++;
+       // }
+       //
+       // // Generate a sequence of bytecodes corresponding to an array allocation
+       // if (this.resolvedType.dimensions() == 1) {
+       // // Mono-dimensional array
+       // codeStream.newArray(currentScope, (ArrayBinding)this.resolvedType);
+       // } else {
+       // // Multi-dimensional array
+       // codeStream.multianewarray(this.resolvedType, nonNullDimensionsLength);
+       // }
+       //
+       // if (valueRequired) {
+       // codeStream.generateImplicitConversion(implicitConversion);
+       // } else {
+       // codeStream.pop();
+       // }
+       //
+       // codeStream.recordPositionsFrom(pc, this.sourceStart);
+       // }
+       public StringBuffer printExpression(int indent, StringBuffer output) {
+
+               output.append("new "); //$NON-NLS-1$
+               type.print(0, output);
+               for (int i = 0; i < dimensions.length; i++) {
+                       if (dimensions[i] == null)
+                               output.append("[]"); //$NON-NLS-1$
+                       else {
+                               output.append('[');
+                               dimensions[i].printExpression(0, output);
+                               output.append(']');
                        }
-
-               // Generate a sequence of bytecodes corresponding to an array allocation
-               if ((arrayTb.isArrayType())
-                       && ((arrayBinding = (ArrayBinding) arrayTb).dimensions == 1)) {
-                       // Mono-dimensional array
-                       codeStream.newArray(currentScope, arrayBinding);
-               } else {
-                       // Multi-dimensional array
-                       codeStream.multianewarray(arrayTb, nonNullDimensionsLength);
                }
-
-               if (valueRequired) {
-                       codeStream.generateImplicitConversion(implicitConversion);
-               } else {
-                       codeStream.pop();
-               }
-
-               codeStream.recordPositionsFrom(pc, this.sourceStart);
+               if (initializer != null)
+                       initializer.printExpression(0, output);
+               return output;
        }
 
        public TypeBinding resolveType(BlockScope scope) {
 
                // Build an array type reference using the current dimensions
                // The parser does not check for the fact that dimension may be null
-               // only at the -end- like new int [4][][]. The parser allows new int[][4][]
-               // so this must be checked here......(this comes from a reduction to LL1 grammar)
+               // only at the -end- like new int [4][][]. The parser allows new
+               // int[][4][]
+               // so this must be checked here......(this comes from a reduction to LL1
+               // grammar)
+
+               TypeBinding referenceType = type.resolveType(scope);
 
-               TypeBinding referenceTb = type.resolveType(scope);
                // will check for null after dimensions are checked
                constant = Constant.NotAConstant;
-               if (referenceTb == VoidBinding) {
+               if (referenceType == VoidBinding) {
                        scope.problemReporter().cannotAllocateVoidArray(this);
-                       referenceTb = null; // will return below
+                       referenceType = null;
                }
 
-               // check the validity of the dimension syntax (and test for all null dimensions)
-               int lengthDim = -1;
+               // check the validity of the dimension syntax (and test for all null
+               // dimensions)
+               int explicitDimIndex = -1;
                for (int i = dimensions.length; --i >= 0;) {
                        if (dimensions[i] != null) {
-                               if (lengthDim == -1)
-                                       lengthDim = i;
-                       } else if (
-                               lengthDim != -1) {
+                               if (explicitDimIndex < 0)
+                                       explicitDimIndex = i;
+                       } else if (explicitDimIndex > 0) {
                                // should not have an empty dimension before an non-empty one
-                               scope.problemReporter().incorrectLocationForEmptyDimension(this, i);
-                               return null;
+                               scope.problemReporter().incorrectLocationForEmptyDimension(
+                                               this, i);
                        }
                }
-               if (referenceTb == null)
-                       return null;
 
-               // lengthDim == -1 says if all dimensions are nulled
+               // explicitDimIndex < 0 says if all dimensions are nulled
                // when an initializer is given, no dimension must be specified
                if (initializer == null) {
-                       if (lengthDim == -1) {
+                       if (explicitDimIndex < 0) {
                                scope.problemReporter().mustDefineDimensionsOrInitializer(this);
-                               return null;
                        }
-               } else if (lengthDim != -1) {
+               } else if (explicitDimIndex >= 0) {
                        scope.problemReporter().cannotDefineDimensionsAndInitializer(this);
-                       return null;
                }
 
-               // dimensions resolution 
-               for (int i = 0; i <= lengthDim; i++) {
-                       TypeBinding dimTb = dimensions[i].resolveTypeExpecting(scope, IntBinding);
-                       if (dimTb == null)
-                               return null;
-                       dimensions[i].implicitWidening(IntBinding, dimTb);
+               // dimensions resolution
+               for (int i = 0; i <= explicitDimIndex; i++) {
+                       if (dimensions[i] != null) {
+                               TypeBinding dimensionType = dimensions[i].resolveTypeExpecting(
+                                               scope, IntBinding);
+                               if (dimensionType != null) {
+                                       dimensions[i].implicitWidening(IntBinding, dimensionType);
+                               }
+                       }
                }
 
                // building the array binding
-               arrayTb = scope.createArray(referenceTb, dimensions.length);
+               if (referenceType != null) {
+                       if (dimensions.length > 255) {
+                               scope.problemReporter().tooManyDimensions(this);
+                       }
+                       this.resolvedType = scope.createArray(referenceType,
+                                       dimensions.length);
 
-               // check the initializer
-               if (initializer != null)
-                       if ((initializer.resolveTypeExpecting(scope, arrayTb)) != null)
-                               initializer.binding = arrayTb;
-               return arrayTb;
+                       // check the initializer
+                       if (initializer != null) {
+                               if ((initializer.resolveTypeExpecting(scope, this.resolvedType)) != null)
+                                       initializer.binding = (ArrayBinding) this.resolvedType;
+                       }
+               }
+               return this.resolvedType;
        }
 
        public String toStringExpression() {
@@ -165,13 +185,13 @@ public class ArrayAllocationExpression extends Expression {
                                s = s + "[]"; //$NON-NLS-1$
                        else
                                s = s + "[" + dimensions[i].toStringExpression() + "]"; //$NON-NLS-2$ //$NON-NLS-1$
-               } 
+               }
                if (initializer != null)
                        s = s + initializer.toStringExpression();
                return s;
        }
 
-       public void traverse(IAbstractSyntaxTreeVisitor visitor, BlockScope scope) {
+       public void traverse(ASTVisitor visitor, BlockScope scope) {
 
                if (visitor.visit(this, scope)) {
                        int dimensionsLength = dimensions.length;
@@ -185,4 +205,4 @@ public class ArrayAllocationExpression extends Expression {
                }
                visitor.endVisit(this, scope);
        }
-}
\ No newline at end of file
+}