net.sourceforge.phpeclipse/src/net/sourceforge/phpeclipse/internal/compiler/ast/ArrayAllocationExpression.java

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2003 IBM Corporation and others.
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Common Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/cpl-v10.html
   7  *
   8  * Contributors:
   9  *     IBM Corporation - initial API and implementation
  10  *******************************************************************************/
  11 package net.sourceforge.phpeclipse.internal.compiler.ast;
  12
  13 import net.sourceforge.phpdt.internal.compiler.IAbstractSyntaxTreeVisitor;
  14 import net.sourceforge.phpdt.internal.compiler.flow.FlowContext;
  15 import net.sourceforge.phpdt.internal.compiler.flow.FlowInfo;
  16 import net.sourceforge.phpdt.internal.compiler.impl.Constant;
  17 import net.sourceforge.phpdt.internal.compiler.lookup.ArrayBinding;
  18 import net.sourceforge.phpdt.internal.compiler.lookup.BlockScope;
  19 import net.sourceforge.phpdt.internal.compiler.lookup.TypeBinding;
  20
  21
  22 public class ArrayAllocationExpression extends Expression {
  23
  24         public TypeReference type;
  25
  26         //dimensions.length gives the number of dimensions, but the
  27         // last ones may be nulled as in new int[4][5][][]
  28         public Expression[] dimensions;
  29         public ArrayInitializer initializer;
  30
  31         /**
  32          * ArrayAllocationExpression constructor comment.
  33          */
  34         public ArrayAllocationExpression() {
  35                 super();
  36         }
  37
  38         public FlowInfo analyseCode(
  39                 BlockScope currentScope,
  40                 FlowContext flowContext,
  41                 FlowInfo flowInfo) {
  42                 for (int i = 0, max = dimensions.length; i < max; i++) {
  43                         Expression dim;
  44                         if ((dim = dimensions[i]) != null) {
  45                                 flowInfo = dim.analyseCode(currentScope, flowContext, flowInfo);
  46                         }
  47                 }
  48                 if (initializer != null) {
  49                         return initializer.analyseCode(currentScope, flowContext, flowInfo);
  50                 } else {
  51                         return flowInfo;
  52                 }
  53         }
  54
  55         /**
  56          * Code generation for a array allocation expression
  57          */
  58 //      public void generateCode(
  59 //              BlockScope currentScope,
  60 //              CodeStream codeStream,
  61 //              boolean valueRequired) {
  62 //
  63 //              int pc = codeStream.position;
  64 //
  65 //              if (initializer != null) {
  66 //                      initializer.generateCode(currentScope, codeStream, valueRequired);
  67 //                      return;
  68 //              }
  69 //
  70 //              int nonNullDimensionsLength = 0;
  71 //              for (int i = 0, max = dimensions.length; i < max; i++)
  72 //                      if (dimensions[i] != null) {
  73 //                              dimensions[i].generateCode(currentScope, codeStream, true);
  74 //                              nonNullDimensionsLength++;
  75 //                      }
  76 //
  77 //              // Generate a sequence of bytecodes corresponding to an array allocation
  78 //              if (this.resolvedType.dimensions() == 1) {
  79 //                      // Mono-dimensional array
  80 //                      codeStream.newArray(currentScope, (ArrayBinding)this.resolvedType);
  81 //              } else {
  82 //                      // Multi-dimensional array
  83 //                      codeStream.multianewarray(this.resolvedType, nonNullDimensionsLength);
  84 //              }
  85 //
  86 //              if (valueRequired) {
  87 //                      codeStream.generateImplicitConversion(implicitConversion);
  88 //              } else {
  89 //                      codeStream.pop();
  90 //              }
  91 //
  92 //              codeStream.recordPositionsFrom(pc, this.sourceStart);
  93 //      }
  94
  95         public TypeBinding resolveType(BlockScope scope) {
  96
  97                 // Build an array type reference using the current dimensions
  98                 // The parser does not check for the fact that dimension may be null
  99                 // only at the -end- like new int [4][][]. The parser allows new int[][4][]
 100                 // so this must be checked here......(this comes from a reduction to LL1 grammar)
 101
 102                 TypeBinding referenceType = type.resolveType(scope);
 103
 104                 // will check for null after dimensions are checked
 105                 constant = Constant.NotAConstant;
 106                 if (referenceType == VoidBinding) {
 107                         scope.problemReporter().cannotAllocateVoidArray(this);
 108                         referenceType = null;
 109                 }
 110
 111                 // check the validity of the dimension syntax (and test for all null dimensions)
 112                 int explicitDimIndex = -1;
 113                 for (int i = dimensions.length; --i >= 0;) {
 114                         if (dimensions[i] != null) {
 115                                 if (explicitDimIndex < 0) explicitDimIndex = i;
 116                         } else if (explicitDimIndex> 0) {
 117                                 // should not have an empty dimension before an non-empty one
 118                                 scope.problemReporter().incorrectLocationForEmptyDimension(this, i);
 119                         }
 120                 }
 121
 122                 // explicitDimIndex < 0 says if all dimensions are nulled
 123                 // when an initializer is given, no dimension must be specified
 124                 if (initializer == null) {
 125                         if (explicitDimIndex < 0) {
 126                                 scope.problemReporter().mustDefineDimensionsOrInitializer(this);
 127                         }
 128                 } else if (explicitDimIndex >= 0) {
 129                         scope.problemReporter().cannotDefineDimensionsAndInitializer(this);
 130                 }
 131
 132                 // dimensions resolution
 133                 for (int i = 0; i <= explicitDimIndex; i++) {
 134                         if (dimensions[i] != null) {
 135                                 TypeBinding dimensionType = dimensions[i].resolveTypeExpecting(scope, IntBinding);
 136                                 if (dimensionType != null) {
 137                                         dimensions[i].implicitWidening(IntBinding, dimensionType);
 138                                 }
 139                         }
 140                 }
 141
 142                 // building the array binding
 143                 if (referenceType != null) {
 144                         if (dimensions.length > 255) {
 145                                 scope.problemReporter().tooManyDimensions(this);
 146                         }
 147                         this.resolvedType = scope.createArray(referenceType, dimensions.length);
 148
 149                         // check the initializer
 150                         if (initializer != null) {
 151                                 if ((initializer.resolveTypeExpecting(scope, this.resolvedType)) != null)
 152                                         initializer.binding = (ArrayBinding)this.resolvedType;
 153                         }
 154                 }
 155                 return this.resolvedType;
 156         }
 157
 158         public String toStringExpression() {
 159
 160                 String s = "new " + type.toString(0); //$NON-NLS-1$
 161                 for (int i = 0; i < dimensions.length; i++) {
 162                         if (dimensions[i] == null)
 163                                 s = s + "[]"; //$NON-NLS-1$
 164                         else
 165                                 s = s + "[" + dimensions[i].toStringExpression() + "]"; //$NON-NLS-2$ //$NON-NLS-1$
 166                 }
 167                 if (initializer != null)
 168                         s = s + initializer.toStringExpression();
 169                 return s;
 170         }
 171
 172         public void traverse(IAbstractSyntaxTreeVisitor visitor, BlockScope scope) {
 173
 174                 if (visitor.visit(this, scope)) {
 175                         int dimensionsLength = dimensions.length;
 176                         type.traverse(visitor, scope);
 177                         for (int i = 0; i < dimensionsLength; i++) {
 178                                 if (dimensions[i] != null)
 179                                         dimensions[i].traverse(visitor, scope);
 180                         }
 181                         if (initializer != null)
 182                                 initializer.traverse(visitor, scope);
 183                 }
 184                 visitor.endVisit(this, scope);
 185         }
 186 }