net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/ast/SwitchStatement.java

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2001, 2002 International Business Machines Corp. and others.
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Common Public License v0.5
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/cpl-v05.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.IAbstractSyntaxTreeVisitor;
  14 import net.sourceforge.phpdt.internal.compiler.codegen.CaseLabel;
  15 import net.sourceforge.phpdt.internal.compiler.codegen.CodeStream;
  16 import net.sourceforge.phpdt.internal.compiler.codegen.Label;
  17 import net.sourceforge.phpdt.internal.compiler.flow.FlowContext;
  18 import net.sourceforge.phpdt.internal.compiler.flow.FlowInfo;
  19 import net.sourceforge.phpdt.internal.compiler.flow.SwitchFlowContext;
  20 import net.sourceforge.phpdt.internal.compiler.impl.Constant;
  21 import net.sourceforge.phpdt.internal.compiler.lookup.BlockScope;
  22 import net.sourceforge.phpdt.internal.compiler.lookup.TypeBinding;
  23
  24 public class SwitchStatement extends Statement {
  25         public Expression testExpression;
  26         public Statement[] statements;
  27         public BlockScope scope;
  28         public int explicitDeclarations;
  29         public Label breakLabel;
  30         public Case[] cases;
  31         public DefaultCase defaultCase;
  32         public int caseCount = 0;
  33
  34         // for local variables table attributes
  35         int preSwitchInitStateIndex = -1;
  36         int mergedInitStateIndex = -1;
  37         /**
  38          * SwitchStatement constructor comment.
  39          */
  40         public SwitchStatement() {
  41                 super();
  42         }
  43         public FlowInfo analyseCode(
  44                 BlockScope currentScope,
  45                 FlowContext flowContext,
  46                 FlowInfo flowInfo) {
  47                 flowInfo = testExpression.analyseCode(currentScope, flowContext, flowInfo);
  48                 SwitchFlowContext switchContext =
  49                         new SwitchFlowContext(flowContext, this, (breakLabel = new Label()));
  50
  51                 // analyse the block by considering specially the case/default statements (need to bind them
  52                 // to the entry point)
  53                 FlowInfo caseInits = FlowInfo.DeadEnd;
  54                 // in case of statements before the first case
  55                 preSwitchInitStateIndex =
  56                         currentScope.methodScope().recordInitializationStates(flowInfo);
  57                 int caseIndex = 0;
  58                 if (statements != null) {
  59                         for (int i = 0, max = statements.length; i < max; i++) {
  60                                 Statement statement = statements[i];
  61                                 if ((caseIndex < caseCount)
  62                                         && (statement == cases[caseIndex])) { // statements[i] is a case or a default case
  63                                         caseIndex++;
  64                                         caseInits = caseInits.mergedWith(flowInfo.copy().unconditionalInits());
  65                                 } else {
  66                                         if (statement == defaultCase) {
  67                                                 caseInits = caseInits.mergedWith(flowInfo.copy().unconditionalInits());
  68                                         }
  69                                 }
  70                                 if (!caseInits.complainIfUnreachable(statement, scope)) {
  71                                         caseInits = statement.analyseCode(scope, switchContext, caseInits);
  72                                 }
  73                         }
  74                 }
  75
  76                 // if no default case, then record it may jump over the block directly to the end
  77                 if (defaultCase == null) {
  78                         // only retain the potential initializations
  79                         flowInfo.addPotentialInitializationsFrom(
  80                                 caseInits.mergedWith(switchContext.initsOnBreak));
  81                         mergedInitStateIndex =
  82                                 currentScope.methodScope().recordInitializationStates(flowInfo);
  83                         return flowInfo;
  84                 }
  85
  86                 // merge all branches inits
  87                 FlowInfo mergedInfo = caseInits.mergedWith(switchContext.initsOnBreak);
  88                 mergedInitStateIndex =
  89                         currentScope.methodScope().recordInitializationStates(mergedInfo);
  90                 return mergedInfo;
  91         }
  92         /**
  93          * Switch code generation
  94          *
  95          * @param currentScope org.eclipse.jdt.internal.compiler.lookup.BlockScope
  96          * @param codeStream org.eclipse.jdt.internal.compiler.codegen.CodeStream
  97          */
  98         public void generateCode(BlockScope currentScope, CodeStream codeStream) {
  99                 int[] sortedIndexes = new int[caseCount];
 100                 int[] localKeysCopy;
 101                 if ((bits & IsReachableMASK) == 0) {
 102                         return;
 103                 }
 104                 int pc = codeStream.position;
 105
 106                 // prepare the labels and constants
 107                 breakLabel.codeStream = codeStream;
 108                 CaseLabel[] caseLabels = new CaseLabel[caseCount];
 109                 int[] constants = new int[caseCount];
 110                 boolean needSwitch = caseCount != 0;
 111                 for (int i = 0; i < caseCount; i++) {
 112                         constants[i] = cases[i].constantExpression.constant.intValue();
 113                         cases[i].targetLabel = (caseLabels[i] = new CaseLabel(codeStream));
 114                 }
 115
 116                 // we sort the keys to be able to generate the code for tableswitch or lookupswitch
 117                 for (int i = 0; i < caseCount; i++) {
 118                         sortedIndexes[i] = i;
 119                 }
 120                 System.arraycopy(
 121                         constants,
 122                         0,
 123                         (localKeysCopy = new int[caseCount]),
 124                         0,
 125                         caseCount);
 126                 CodeStream.sort(localKeysCopy, 0, caseCount - 1, sortedIndexes);
 127                 CaseLabel defaultLabel = new CaseLabel(codeStream);
 128                 if (defaultCase != null) {
 129                         defaultCase.targetLabel = defaultLabel;
 130                 }
 131                 // generate expression testes
 132                 testExpression.generateCode(currentScope, codeStream, needSwitch);
 133
 134                 // generate the appropriate switch table
 135                 if (needSwitch) {
 136                         int max = localKeysCopy[caseCount - 1];
 137                         int min = localKeysCopy[0];
 138                         if ((long) (caseCount * 2.5) > ((long) max - (long) min)) {
 139                                 codeStream.tableswitch(
 140                                         defaultLabel,
 141                                         min,
 142                                         max,
 143                                         constants,
 144                                         sortedIndexes,
 145                                         caseLabels);
 146                         } else {
 147                                 codeStream.lookupswitch(defaultLabel, constants, sortedIndexes, caseLabels);
 148                         }
 149                         codeStream.updateLastRecordedEndPC(codeStream.position);
 150                 }
 151                 // generate the switch block statements
 152                 int caseIndex = 0;
 153                 if (statements != null) {
 154                         for (int i = 0, maxCases = statements.length; i < maxCases; i++) {
 155                                 Statement statement = statements[i];
 156                                 if ((caseIndex < caseCount)
 157                                         && (statement == cases[caseIndex])) { // statements[i] is a case
 158                                         if (preSwitchInitStateIndex != -1) {
 159                                                 codeStream.removeNotDefinitelyAssignedVariables(
 160                                                         currentScope,
 161                                                         preSwitchInitStateIndex);
 162                                                 caseIndex++;
 163                                         }
 164                                 } else {
 165                                         if (statement == defaultCase) { // statements[i] is a case or a default case
 166                                                 if (preSwitchInitStateIndex != -1) {
 167                                                         codeStream.removeNotDefinitelyAssignedVariables(
 168                                                                 currentScope,
 169                                                                 preSwitchInitStateIndex);
 170                                                 }
 171                                         }
 172                                 }
 173                                 statement.generateCode(scope, codeStream);
 174                         }
 175                 }
 176                 // place the trailing labels (for break and default case)
 177                 breakLabel.place();
 178                 if (defaultCase == null) {
 179                         defaultLabel.place();
 180                 }
 181                 // May loose some local variable initializations : affecting the local variable attributes
 182                 if (mergedInitStateIndex != -1) {
 183                         codeStream.removeNotDefinitelyAssignedVariables(
 184                                 currentScope,
 185                                 mergedInitStateIndex);
 186                         codeStream.addDefinitelyAssignedVariables(currentScope, mergedInitStateIndex);
 187                 }
 188                 if (scope != currentScope) {
 189                         codeStream.exitUserScope(scope);
 190                 }
 191                 codeStream.recordPositionsFrom(pc, this.sourceStart);
 192         }
 193
 194
 195         public void resetStateForCodeGeneration() {
 196
 197                 this.breakLabel.resetStateForCodeGeneration();
 198         }
 199
 200         public void resolve(BlockScope upperScope) {
 201
 202                 TypeBinding testType = testExpression.resolveType(upperScope);
 203                 if (testType == null)
 204                         return;
 205                 testExpression.implicitWidening(testType, testType);
 206                 if (!(testExpression
 207                         .isConstantValueOfTypeAssignableToType(testType, IntBinding))) {
 208                         if (!BlockScope.areTypesCompatible(testType, IntBinding)) {
 209                                 upperScope.problemReporter().incorrectSwitchType(testExpression, testType);
 210                                 return;
 211                         }
 212                 }
 213                 if (statements != null) {
 214                         scope = explicitDeclarations == 0 ? upperScope : new BlockScope(upperScope);
 215                         int length;
 216                         // collection of cases is too big but we will only iterate until caseCount
 217                         cases = new Case[length = statements.length];
 218                         int[] casesValues = new int[length];
 219                         int counter = 0;
 220                         for (int i = 0; i < length; i++) {
 221                                 Constant cst;
 222                                 if ((cst = statements[i].resolveCase(scope, testType, this)) != null) {
 223                                         //----check for duplicate case statement------------
 224                                         if (cst != NotAConstant) {
 225                                                 int key = cst.intValue();
 226                                                 for (int j = 0; j < counter; j++) {
 227                                                         if (casesValues[j] == key) {
 228                                                                 scope.problemReporter().duplicateCase((Case) statements[i], cst);
 229                                                         }
 230                                                 }
 231                                                 casesValues[counter++] = key;
 232                                         }
 233                                 }
 234                         }
 235                 }
 236         }
 237         public String toString(int tab) {
 238
 239                 String inFront, s = tabString(tab);
 240                 inFront = s;
 241                 s = s + "switch (" + testExpression.toStringExpression() + ") "; //$NON-NLS-1$ //$NON-NLS-2$
 242                 if (statements == null) {
 243                         s = s + "{}"; //$NON-NLS-1$
 244                         return s;
 245                 } else
 246                         s = s + "{"; //$NON-NLS-1$
 247                         s = s
 248                                         + (explicitDeclarations != 0
 249                                                 ? "// ---scope needed for " //$NON-NLS-1$
 250                                                         + String.valueOf(explicitDeclarations)
 251                                                         + " locals------------ \n"//$NON-NLS-1$
 252                                                 : "// ---NO scope needed------ \n"); //$NON-NLS-1$
 253
 254                 int i = 0;
 255                 String tabulation = "  "; //$NON-NLS-1$
 256                 try {
 257                         while (true) {
 258                                 //use instanceof in order not to polluate classes with behavior only needed for printing purpose.
 259                                 if (statements[i] instanceof Expression)
 260                                         s = s + "\n" + inFront + tabulation; //$NON-NLS-1$
 261                                 if (statements[i] instanceof Break)
 262                                         s = s + statements[i].toString(0);
 263                                 else
 264                                         s = s + "\n" + statements[i].toString(tab + 2); //$NON-NLS-1$
 265                                 //=============
 266                                 if ((statements[i] instanceof Case)
 267                                         || (statements[i] instanceof DefaultCase)) {
 268                                         i++;
 269                                         while (!((statements[i] instanceof Case)
 270                                                 || (statements[i] instanceof DefaultCase))) {
 271                                                 if ((statements[i] instanceof Expression) || (statements[i] instanceof Break))
 272                                                         s = s + statements[i].toString(0) + " ; "; //$NON-NLS-1$
 273                                                 else
 274                                                         s = s + "\n" + statements[i].toString(tab + 6) + " ; "; //$NON-NLS-1$ //$NON-NLS-2$
 275                                                 i++;
 276                                         }
 277                                 } else {
 278                                         s = s + " ;"; //$NON-NLS-1$
 279                                         i++;
 280                                 }
 281                         }
 282                 } catch (IndexOutOfBoundsException e) {
 283                 };
 284                 s = s + "}"; //$NON-NLS-1$
 285                 return s;
 286         }
 287
 288         public void traverse(
 289                 IAbstractSyntaxTreeVisitor visitor,
 290                 BlockScope blockScope) {
 291
 292                 if (visitor.visit(this, blockScope)) {
 293                         testExpression.traverse(visitor, scope);
 294                         if (statements != null) {
 295                                 int statementsLength = statements.length;
 296                                 for (int i = 0; i < statementsLength; i++)
 297                                         statements[i].traverse(visitor, scope);
 298                         }
 299                 }
 300                 visitor.endVisit(this, blockScope);
 301         }
 302
 303         /**
 304          * Dispatch the call on its last statement.
 305          */
 306         public void branchChainTo(Label label) {
 307
 308                 // in order to improve debug attributes for stepping (11431)
 309                 // we want to inline the jumps to #breakLabel which already got
 310                 // generated (if any), and have them directly branch to a better
 311                 // location (the argument label).
 312                 // we know at this point that the breakLabel already got placed
 313                 if (this.breakLabel.hasForwardReferences()) {
 314                         label.appendForwardReferencesFrom(this.breakLabel);
 315                 }
 316         }
 317 }