net.sourceforge.phpeclipse/src/net/sourceforge/phpeclipse/internal/compiler/ast/WhileStatement.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.codegen.Label;
  15 import net.sourceforge.phpdt.internal.compiler.flow.FlowContext;
  16 import net.sourceforge.phpdt.internal.compiler.flow.FlowInfo;
  17 import net.sourceforge.phpdt.internal.compiler.flow.LoopingFlowContext;
  18 import net.sourceforge.phpdt.internal.compiler.impl.Constant;
  19 import net.sourceforge.phpdt.internal.compiler.lookup.BlockScope;
  20 import net.sourceforge.phpdt.internal.compiler.lookup.TypeBinding;
  21
  22
  23 public class WhileStatement extends Statement {
  24
  25         public Expression condition;
  26         public Statement action;
  27         private Label breakLabel, continueLabel;
  28         int preCondInitStateIndex = -1;
  29         int condIfTrueInitStateIndex = -1;
  30         int mergedInitStateIndex = -1;
  31
  32         public WhileStatement(Expression condition, Statement action, int s, int e) {
  33
  34                 this.condition = condition;
  35                 this.action = action;
  36                 sourceStart = s;
  37                 sourceEnd = e;
  38         }
  39
  40         public FlowInfo analyseCode(
  41                 BlockScope currentScope,
  42                 FlowContext flowContext,
  43                 FlowInfo flowInfo) {
  44
  45                 breakLabel = new Label();
  46                 continueLabel = new Label();
  47
  48                 Constant cst = this.condition.constant;
  49                 boolean isConditionTrue = cst != NotAConstant && cst.booleanValue() == true;
  50                 boolean isConditionFalse = cst != NotAConstant && cst.booleanValue() == false;
  51
  52                 cst = this.condition.optimizedBooleanConstant();
  53                 boolean isConditionOptimizedTrue = cst != NotAConstant && cst.booleanValue() == true;
  54                 boolean isConditionOptimizedFalse = cst != NotAConstant && cst.booleanValue() == false;
  55
  56                 preCondInitStateIndex =
  57                         currentScope.methodScope().recordInitializationStates(flowInfo);
  58                 LoopingFlowContext condLoopContext;
  59                 FlowInfo postCondInfo =
  60                         this.condition.analyseCode(
  61                                 currentScope,
  62                                 (condLoopContext =
  63                                         new LoopingFlowContext(flowContext, this, null, null, currentScope)),
  64                                 flowInfo);
  65
  66                 LoopingFlowContext loopingContext;
  67                 FlowInfo actionInfo;
  68 //              if (action == null
  69 //                      || (action.isEmptyBlock() && currentScope.environment().options.complianceLevel <= CompilerOptions.JDK1_3)) {
  70 //                      condLoopContext.complainOnFinalAssignmentsInLoop(currentScope, postCondInfo);
  71 //                      if (isConditionTrue) {
  72 //                              return FlowInfo.DEAD_END;
  73 //                      } else {
  74 //                              FlowInfo mergedInfo = postCondInfo.initsWhenFalse().unconditionalInits();
  75 //                              if (isConditionOptimizedTrue){
  76 //                                      mergedInfo.setReachMode(FlowInfo.UNREACHABLE);
  77 //                              }
  78 //                              mergedInitStateIndex =
  79 //                                      currentScope.methodScope().recordInitializationStates(mergedInfo);
  80 //                              return mergedInfo;
  81 //                      }
  82 //              } else {
  83                         // in case the condition was inlined to false, record the fact that there is no way to reach any
  84                         // statement inside the looping action
  85                         loopingContext =
  86                                 new LoopingFlowContext(
  87                                         flowContext,
  88                                         this,
  89                                         breakLabel,
  90                                         continueLabel,
  91                                         currentScope);
  92                         if (isConditionFalse) {
  93                                 actionInfo = FlowInfo.DEAD_END;
  94                         } else {
  95                                 actionInfo = postCondInfo.initsWhenTrue().copy();
  96                                 if (isConditionOptimizedFalse){
  97                                         actionInfo.setReachMode(FlowInfo.UNREACHABLE);
  98                                 }
  99                         }
 100
 101                         // for computing local var attributes
 102                         condIfTrueInitStateIndex =
 103                                 currentScope.methodScope().recordInitializationStates(
 104                                         postCondInfo.initsWhenTrue());
 105
 106                         if (!actionInfo.complainIfUnreachable(action, currentScope, false)) {
 107                                 actionInfo = action.analyseCode(currentScope, loopingContext, actionInfo);
 108                         }
 109
 110                         // code generation can be optimized when no need to continue in the loop
 111                         if (!actionInfo.isReachable() && !loopingContext.initsOnContinue.isReachable()) {
 112                                 continueLabel = null;
 113                         } else {
 114                                 // TODO: (philippe) should simplify in one Loop context
 115                                 condLoopContext.complainOnFinalAssignmentsInLoop(currentScope, postCondInfo);
 116                                 loopingContext.complainOnFinalAssignmentsInLoop(currentScope, actionInfo);
 117                         }
 118 //              }
 119
 120                 // infinite loop
 121                 FlowInfo mergedInfo;
 122                 if (isConditionOptimizedTrue) {
 123                         mergedInitStateIndex =
 124                                 currentScope.methodScope().recordInitializationStates(
 125                                         mergedInfo = loopingContext.initsOnBreak);
 126                         return mergedInfo;
 127                 }
 128
 129                 // end of loop: either condition false or break
 130                 mergedInfo =
 131                         postCondInfo.initsWhenFalse().unconditionalInits().mergedWith(
 132                                 loopingContext.initsOnBreak);
 133                 if (isConditionOptimizedTrue && continueLabel == null){
 134                         mergedInfo.setReachMode(FlowInfo.UNREACHABLE);
 135                 }
 136                 mergedInitStateIndex =
 137                         currentScope.methodScope().recordInitializationStates(mergedInfo);
 138                 return mergedInfo;
 139         }
 140
 141         /**
 142          * While code generation
 143          *
 144          * @param currentScope org.eclipse.jdt.internal.compiler.lookup.BlockScope
 145          * @param codeStream org.eclipse.jdt.internal.compiler.codegen.CodeStream
 146          */
 147 //      public void generateCode(BlockScope currentScope, CodeStream codeStream) {
 148 //
 149 //              if ((bits & IsReachableMASK) == 0) {
 150 //                      return;
 151 //              }
 152 //              int pc = codeStream.position;
 153 //              breakLabel.codeStream = codeStream;
 154 //
 155 //              // generate condition
 156 //              if (continueLabel == null) {
 157 //                      // no need to reverse condition
 158 //                      if (condition.constant == NotAConstant) {
 159 //                              condition.generateOptimizedBoolean(
 160 //                                      currentScope,
 161 //                                      codeStream,
 162 //                                      null,
 163 //                                      breakLabel,
 164 //                                      true);
 165 //                      }
 166 //              } else {
 167 //                      continueLabel.codeStream = codeStream;
 168 //                      if (!(((condition.constant != NotAConstant)
 169 //                              && (condition.constant.booleanValue() == true))
 170 //                              || (action == null)
 171 //                              || action.isEmptyBlock())) {
 172 //                              int jumpPC = codeStream.position;
 173 //                              codeStream.goto_(continueLabel);
 174 //                              codeStream.recordPositionsFrom(jumpPC, condition.sourceStart);
 175 //                      }
 176 //              }
 177 //              // generate the action
 178 //              Label actionLabel;
 179 //              (actionLabel = new Label(codeStream)).place();
 180 //              if (action != null) {
 181 //                      // Required to fix 1PR0XVS: LFRE:WINNT - Compiler: variable table for method appears incorrect
 182 //                      if (condIfTrueInitStateIndex != -1) {
 183 //                              // insert all locals initialized inside the condition into the action generated prior to the condition
 184 //                              codeStream.addDefinitelyAssignedVariables(
 185 //                                      currentScope,
 186 //                                      condIfTrueInitStateIndex);
 187 //                      }
 188 //                      action.generateCode(currentScope, codeStream);
 189 //                      // May loose some local variable initializations : affecting the local variable attributes
 190 //                      if (preCondInitStateIndex != -1) {
 191 //                              codeStream.removeNotDefinitelyAssignedVariables(
 192 //                                      currentScope,
 193 //                                      preCondInitStateIndex);
 194 //                      }
 195 //
 196 //              }
 197 //              // output condition and branch back to the beginning of the repeated action
 198 //              if (continueLabel != null) {
 199 //                      continueLabel.place();
 200 //                      condition.generateOptimizedBoolean(
 201 //                              currentScope,
 202 //                              codeStream,
 203 //                              actionLabel,
 204 //                              null,
 205 //                              true);
 206 //              }
 207 //              breakLabel.place();
 208 //
 209 //              // May loose some local variable initializations : affecting the local variable attributes
 210 //              if (mergedInitStateIndex != -1) {
 211 //                      codeStream.removeNotDefinitelyAssignedVariables(
 212 //                              currentScope,
 213 //                              mergedInitStateIndex);
 214 //              }
 215 //              codeStream.recordPositionsFrom(pc, this.sourceStart);
 216 //      }
 217
 218         public void resetStateForCodeGeneration() {
 219                 if (this.breakLabel != null) {
 220                         this.breakLabel.resetStateForCodeGeneration();
 221                 }
 222                 if (this.continueLabel != null) {
 223                         this.continueLabel.resetStateForCodeGeneration();
 224                 }
 225         }
 226
 227         public void resolve(BlockScope scope) {
 228
 229                 TypeBinding type = condition.resolveTypeExpecting(scope, BooleanBinding);
 230                 condition.implicitWidening(type, type);
 231                 if (action != null)
 232                         action.resolve(scope);
 233         }
 234
 235         public String toString(int tab) {
 236
 237                 String s = tabString(tab);
 238                 s = s + "while (" + condition.toStringExpression() + ")";       //$NON-NLS-1$ //$NON-NLS-2$
 239                 if (action == null)
 240                         s = s + " {} ;"; //$NON-NLS-1$
 241                 else if (action instanceof Block)
 242                         s = s + "\n" + action.toString(tab + 1); //$NON-NLS-1$
 243                 else
 244                         s = s + " {\n" + action.toString(tab + 1) + "}"; //$NON-NLS-2$ //$NON-NLS-1$
 245                 return s;
 246         }
 247
 248         public void traverse(
 249                 IAbstractSyntaxTreeVisitor visitor,
 250                 BlockScope blockScope) {
 251
 252                 if (visitor.visit(this, blockScope)) {
 253                         condition.traverse(visitor, blockScope);
 254                         if (action != null)
 255                                 action.traverse(visitor, blockScope);
 256                 }
 257                 visitor.endVisit(this, blockScope);
 258         }
 259 }