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