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