src/org/eclipse/jdt/internal/compiler/ast/ArrayReference.java

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2004 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 org.eclipse.jdt.internal.compiler.ast;
  12
  13 import org.eclipse.jdt.internal.compiler.ASTVisitor;
  14 import org.eclipse.jdt.internal.compiler.impl.*;
  15 import org.eclipse.jdt.internal.compiler.codegen.*;
  16 import org.eclipse.jdt.internal.compiler.flow.*;
  17 import org.eclipse.jdt.internal.compiler.lookup.*;
  18
  19 public class ArrayReference extends Reference {
  20
  21         public Expression receiver;
  22         public Expression position;
  23
  24         public ArrayReference(Expression rec, Expression pos) {
  25                 this.receiver = rec;
  26                 this.position = pos;
  27                 sourceStart = rec.sourceStart;
  28         }
  29
  30         public FlowInfo analyseAssignment(
  31                 BlockScope currentScope,
  32                 FlowContext flowContext,
  33                 FlowInfo flowInfo,
  34                 Assignment assignment,
  35                 boolean compoundAssignment) {
  36
  37                 if (assignment.expression == null) {
  38                         return analyseCode(currentScope, flowContext, flowInfo).unconditionalInits();
  39                 }
  40                 return assignment
  41                         .expression
  42                         .analyseCode(
  43                                 currentScope,
  44                                 flowContext,
  45                                 analyseCode(currentScope, flowContext, flowInfo).unconditionalInits())
  46                         .unconditionalInits();
  47         }
  48
  49         public FlowInfo analyseCode(
  50                 BlockScope currentScope,
  51                 FlowContext flowContext,
  52                 FlowInfo flowInfo) {
  53
  54                 return position.analyseCode(
  55                         currentScope,
  56                         flowContext,
  57                         receiver.analyseCode(currentScope, flowContext, flowInfo));
  58         }
  59
  60         public void generateAssignment(
  61                 BlockScope currentScope,
  62                 CodeStream codeStream,
  63                 Assignment assignment,
  64                 boolean valueRequired) {
  65
  66                 receiver.generateCode(currentScope, codeStream, true);
  67                 if (receiver instanceof CastExpression  // ((type[])null)[0]
  68                                 && ((CastExpression)receiver).innermostCastedExpression().resolvedType == NullBinding){
  69                         codeStream.checkcast(receiver.resolvedType);
  70                 }
  71                 position.generateCode(currentScope, codeStream, true);
  72                 assignment.expression.generateCode(currentScope, codeStream, true);
  73                 codeStream.arrayAtPut(this.resolvedType.id, valueRequired);
  74                 if (valueRequired) {
  75                         codeStream.generateImplicitConversion(assignment.implicitConversion);
  76                 }
  77         }
  78
  79         /**
  80          * Code generation for a array reference
  81          */
  82         public void generateCode(
  83                 BlockScope currentScope,
  84                 CodeStream codeStream,
  85                 boolean valueRequired) {
  86
  87                 int pc = codeStream.position;
  88                 receiver.generateCode(currentScope, codeStream, true);
  89                 if (receiver instanceof CastExpression  // ((type[])null)[0]
  90                                 && ((CastExpression)receiver).innermostCastedExpression().resolvedType == NullBinding){
  91                         codeStream.checkcast(receiver.resolvedType);
  92                 }
  93                 position.generateCode(currentScope, codeStream, true);
  94                 codeStream.arrayAt(this.resolvedType.id);
  95                 // Generating code for the potential runtime type checking
  96                 if (valueRequired) {
  97                         codeStream.generateImplicitConversion(implicitConversion);
  98                 } else {
  99                         if (this.resolvedType == LongBinding
 100                                 || this.resolvedType == DoubleBinding) {
 101                                 codeStream.pop2();
 102                         } else {
 103                                 codeStream.pop();
 104                         }
 105                 }
 106                 codeStream.recordPositionsFrom(pc, this.sourceStart);
 107         }
 108
 109         public void generateCompoundAssignment(
 110                 BlockScope currentScope,
 111                 CodeStream codeStream,
 112                 Expression expression,
 113                 int operator,
 114                 int assignmentImplicitConversion,
 115                 boolean valueRequired) {
 116
 117                 receiver.generateCode(currentScope, codeStream, true);
 118                 if (receiver instanceof CastExpression  // ((type[])null)[0]
 119                                 && ((CastExpression)receiver).innermostCastedExpression().resolvedType == NullBinding){
 120                         codeStream.checkcast(receiver.resolvedType);
 121                 }
 122                 position.generateCode(currentScope, codeStream, true);
 123                 codeStream.dup2();
 124                 codeStream.arrayAt(this.resolvedType.id);
 125                 int operationTypeID;
 126                 if ((operationTypeID = implicitConversion >> 4) == T_String) {
 127                         codeStream.generateStringAppend(currentScope, null, expression);
 128                 } else {
 129                         // promote the array reference to the suitable operation type
 130                         codeStream.generateImplicitConversion(implicitConversion);
 131                         // generate the increment value (will by itself  be promoted to the operation value)
 132                         if (expression == IntLiteral.One) { // prefix operation
 133                                 codeStream.generateConstant(expression.constant, implicitConversion);
 134                         } else {
 135                                 expression.generateCode(currentScope, codeStream, true);
 136                         }
 137                         // perform the operation
 138                         codeStream.sendOperator(operator, operationTypeID);
 139                         // cast the value back to the array reference type
 140                         codeStream.generateImplicitConversion(assignmentImplicitConversion);
 141                 }
 142                 codeStream.arrayAtPut(this.resolvedType.id, valueRequired);
 143         }
 144
 145         public void generatePostIncrement(
 146                 BlockScope currentScope,
 147                 CodeStream codeStream,
 148                 CompoundAssignment postIncrement,
 149                 boolean valueRequired) {
 150
 151                 receiver.generateCode(currentScope, codeStream, true);
 152                 if (receiver instanceof CastExpression  // ((type[])null)[0]
 153                                 && ((CastExpression)receiver).innermostCastedExpression().resolvedType == NullBinding){
 154                         codeStream.checkcast(receiver.resolvedType);
 155                 }
 156                 position.generateCode(currentScope, codeStream, true);
 157                 codeStream.dup2();
 158                 codeStream.arrayAt(this.resolvedType.id);
 159                 if (valueRequired) {
 160                         if ((this.resolvedType == LongBinding)
 161                                 || (this.resolvedType == DoubleBinding)) {
 162                                 codeStream.dup2_x2();
 163                         } else {
 164                                 codeStream.dup_x2();
 165                         }
 166                 }
 167                 codeStream.generateConstant(
 168                         postIncrement.expression.constant,
 169                         implicitConversion);
 170                 codeStream.sendOperator(postIncrement.operator, this.resolvedType.id);
 171                 codeStream.generateImplicitConversion(
 172                         postIncrement.assignmentImplicitConversion);
 173                 codeStream.arrayAtPut(this.resolvedType.id, false);
 174         }
 175
 176         public StringBuffer printExpression(int indent, StringBuffer output) {
 177
 178                 receiver.printExpression(0, output).append('[');
 179                 return position.printExpression(0, output).append(']');
 180         }
 181
 182         public TypeBinding resolveType(BlockScope scope) {
 183
 184                 constant = Constant.NotAConstant;
 185                 if (receiver instanceof CastExpression  // no cast check for ((type[])null)[0]
 186                                 && ((CastExpression)receiver).innermostCastedExpression() instanceof NullLiteral) {
 187                         this.receiver.bits |= IgnoreNeedForCastCheckMASK; // will check later on
 188                 }
 189                 TypeBinding arrayType = receiver.resolveType(scope);
 190                 if (arrayType != null) {
 191                         if (arrayType.isArrayType()) {
 192                                 this.resolvedType = ((ArrayBinding) arrayType).elementsType(scope);
 193                         } else {
 194                                 scope.problemReporter().referenceMustBeArrayTypeAt(arrayType, this);
 195                         }
 196                 }
 197                 TypeBinding positionType = position.resolveTypeExpecting(scope, IntBinding);
 198                 if (positionType != null) {
 199                         position.implicitWidening(IntBinding, positionType);
 200                 }
 201                 return this.resolvedType;
 202         }
 203
 204         public void traverse(ASTVisitor visitor, BlockScope scope) {
 205
 206                 if (visitor.visit(this, scope)) {
 207                         receiver.traverse(visitor, scope);
 208                         position.traverse(visitor, scope);
 209                 }
 210                 visitor.endVisit(this, scope);
 211         }
 212 }