Refactory: remove unused classes, imports, fields and methods.
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / compiler / ast / ConditionalExpression.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.flow.UnconditionalFlowInfo;
17 import net.sourceforge.phpdt.internal.compiler.impl.Constant;
18 import net.sourceforge.phpdt.internal.compiler.lookup.BlockScope;
19
20 public class ConditionalExpression extends OperatorExpression {
21
22         public Expression condition, valueIfTrue, valueIfFalse;
23
24         public Constant optimizedBooleanConstant;
25
26         public Constant optimizedIfTrueConstant;
27
28         public Constant optimizedIfFalseConstant;
29
30         //private int returnTypeSlotSize = 1;
31
32         // for local variables table attributes
33         int trueInitStateIndex = -1;
34
35         int falseInitStateIndex = -1;
36
37         int mergedInitStateIndex = -1;
38
39         public ConditionalExpression(Expression condition, Expression valueIfTrue,
40                         Expression valueIfFalse) {
41                 this.condition = condition;
42                 this.valueIfTrue = valueIfTrue;
43                 this.valueIfFalse = valueIfFalse;
44                 sourceStart = condition.sourceStart;
45                 sourceEnd = valueIfFalse.sourceEnd;
46         }
47
48         public FlowInfo analyseCode(BlockScope currentScope,
49                         FlowContext flowContext, FlowInfo flowInfo) {
50
51                 Constant cst = this.condition.optimizedBooleanConstant();
52                 boolean isConditionOptimizedTrue = cst != NotAConstant
53                                 && cst.booleanValue() == true;
54                 boolean isConditionOptimizedFalse = cst != NotAConstant
55                                 && cst.booleanValue() == false;
56
57                 int mode = flowInfo.reachMode();
58                 flowInfo = condition.analyseCode(currentScope, flowContext, flowInfo,
59                                 cst == NotAConstant);
60
61                 // process the if-true part
62                 FlowInfo trueFlowInfo = flowInfo.initsWhenTrue().copy();
63                 if (isConditionOptimizedFalse) {
64                         trueFlowInfo.setReachMode(FlowInfo.UNREACHABLE);
65                 }
66                 trueInitStateIndex = currentScope.methodScope()
67                                 .recordInitializationStates(trueFlowInfo);
68                 trueFlowInfo = valueIfTrue.analyseCode(currentScope, flowContext,
69                                 trueFlowInfo);
70
71                 // process the if-false part
72                 FlowInfo falseFlowInfo = flowInfo.initsWhenFalse().copy();
73                 if (isConditionOptimizedTrue) {
74                         falseFlowInfo.setReachMode(FlowInfo.UNREACHABLE);
75                 }
76                 falseInitStateIndex = currentScope.methodScope()
77                                 .recordInitializationStates(falseFlowInfo);
78                 falseFlowInfo = valueIfFalse.analyseCode(currentScope, flowContext,
79                                 falseFlowInfo);
80
81                 // merge if-true & if-false initializations
82                 FlowInfo mergedInfo;
83                 if (isConditionOptimizedTrue) {
84                         mergedInfo = trueFlowInfo
85                                         .addPotentialInitializationsFrom(falseFlowInfo);
86                 } else if (isConditionOptimizedFalse) {
87                         mergedInfo = falseFlowInfo
88                                         .addPotentialInitializationsFrom(trueFlowInfo);
89                 } else {
90                         // merge using a conditional info - 1GK2BLM
91                         // if ((t && (v = t)) ? t : t && (v = f)) r = v; -- ok
92                         cst = this.optimizedIfTrueConstant;
93                         boolean isValueIfTrueOptimizedTrue = cst != null
94                                         && cst != NotAConstant && cst.booleanValue() == true;
95                         boolean isValueIfTrueOptimizedFalse = cst != null
96                                         && cst != NotAConstant && cst.booleanValue() == false;
97
98                         cst = this.optimizedIfFalseConstant;
99                         boolean isValueIfFalseOptimizedTrue = cst != null
100                                         && cst != NotAConstant && cst.booleanValue() == true;
101                         boolean isValueIfFalseOptimizedFalse = cst != null
102                                         && cst != NotAConstant && cst.booleanValue() == false;
103
104                         UnconditionalFlowInfo trueInfoWhenTrue = trueFlowInfo
105                                         .initsWhenTrue().copy().unconditionalInits();
106                         if (isValueIfTrueOptimizedFalse)
107                                 trueInfoWhenTrue.setReachMode(FlowInfo.UNREACHABLE);
108
109                         UnconditionalFlowInfo falseInfoWhenTrue = falseFlowInfo
110                                         .initsWhenTrue().copy().unconditionalInits();
111                         if (isValueIfFalseOptimizedFalse)
112                                 falseInfoWhenTrue.setReachMode(FlowInfo.UNREACHABLE);
113
114                         UnconditionalFlowInfo trueInfoWhenFalse = trueFlowInfo
115                                         .initsWhenFalse().copy().unconditionalInits();
116                         if (isValueIfTrueOptimizedTrue)
117                                 trueInfoWhenFalse.setReachMode(FlowInfo.UNREACHABLE);
118
119                         UnconditionalFlowInfo falseInfoWhenFalse = falseFlowInfo
120                                         .initsWhenFalse().copy().unconditionalInits();
121                         if (isValueIfFalseOptimizedTrue)
122                                 falseInfoWhenFalse.setReachMode(FlowInfo.UNREACHABLE);
123
124                         mergedInfo = FlowInfo.conditional(trueInfoWhenTrue
125                                         .mergedWith(falseInfoWhenTrue), trueInfoWhenFalse
126                                         .mergedWith(falseInfoWhenFalse));
127                 }
128                 mergedInitStateIndex = currentScope.methodScope()
129                                 .recordInitializationStates(mergedInfo);
130                 mergedInfo.setReachMode(mode);
131                 return mergedInfo;
132         }
133
134         /**
135          * Code generation for the conditional operator ?:
136          * 
137          * @param currentScope
138          *            net.sourceforge.phpdt.internal.compiler.lookup.BlockScope
139          * @param codeStream
140          *            net.sourceforge.phpdt.internal.compiler.codegen.CodeStream
141          * @param valueRequired
142          *            boolean
143          */
144         // public void generateCode(
145         // BlockScope currentScope,
146         // CodeStream codeStream,
147         // boolean valueRequired) {
148         //
149         // int pc = codeStream.position;
150         // Label endifLabel, falseLabel;
151         // if (constant != NotAConstant) {
152         // if (valueRequired)
153         // codeStream.generateConstant(constant, implicitConversion);
154         // codeStream.recordPositionsFrom(pc, this.sourceStart);
155         // return;
156         // }
157         // Constant cst = condition.constant;
158         // Constant condCst = condition.optimizedBooleanConstant();
159         // boolean needTruePart =
160         // !(((cst != NotAConstant) && (cst.booleanValue() == false))
161         // || ((condCst != NotAConstant) && (condCst.booleanValue() == false)));
162         // boolean needFalsePart =
163         // !(((cst != NotAConstant) && (cst.booleanValue() == true))
164         // || ((condCst != NotAConstant) && (condCst.booleanValue() == true)));
165         // endifLabel = new Label(codeStream);
166         //
167         // // Generate code for the condition
168         // boolean needConditionValue = (cst == NotAConstant) && (condCst ==
169         // NotAConstant);
170         // condition.generateOptimizedBoolean(
171         // currentScope,
172         // codeStream,
173         // null,
174         // (falseLabel = new Label(codeStream)),
175         // needConditionValue);
176         //
177         // if (trueInitStateIndex != -1) {
178         // codeStream.removeNotDefinitelyAssignedVariables(
179         // currentScope,
180         // trueInitStateIndex);
181         // codeStream.addDefinitelyAssignedVariables(currentScope,
182         // trueInitStateIndex);
183         // }
184         // // Then code generation
185         // if (needTruePart) {
186         // valueIfTrue.generateCode(currentScope, codeStream, valueRequired);
187         // if (needFalsePart) {
188         // // Jump over the else part
189         // int position = codeStream.position;
190         // codeStream.goto_(endifLabel);
191         // codeStream.updateLastRecordedEndPC(position);
192         // // Tune codestream stack size
193         // if (valueRequired) {
194         // codeStream.decrStackSize(returnTypeSlotSize);
195         // }
196         // }
197         // }
198         // if (needFalsePart) {
199         // falseLabel.place();
200         // if (falseInitStateIndex != -1) {
201         // codeStream.removeNotDefinitelyAssignedVariables(
202         // currentScope,
203         // falseInitStateIndex);
204         // codeStream.addDefinitelyAssignedVariables(currentScope,
205         // falseInitStateIndex);
206         // }
207         // valueIfFalse.generateCode(currentScope, codeStream, valueRequired);
208         // // End of if statement
209         // endifLabel.place();
210         // }
211         // // May loose some local variable initializations : affecting the local
212         // variable attributes
213         // if (mergedInitStateIndex != -1) {
214         // codeStream.removeNotDefinitelyAssignedVariables(
215         // currentScope,
216         // mergedInitStateIndex);
217         // }
218         // // implicit conversion
219         // if (valueRequired)
220         // codeStream.generateImplicitConversion(implicitConversion);
221         // codeStream.recordPositionsFrom(pc, this.sourceStart);
222         // }
223         //
224         // /**
225         // * Optimized boolean code generation for the conditional operator ?:
226         // */
227         // public void generateOptimizedBoolean(
228         // BlockScope currentScope,
229         // CodeStream codeStream,
230         // Label trueLabel,
231         // Label falseLabel,
232         // boolean valueRequired) {
233         //
234         // if ((constant != Constant.NotAConstant) && (constant.typeID() ==
235         // T_boolean) // constant
236         // || (valueIfTrue.implicitConversion >> 4) != T_boolean) { // non boolean
237         // values
238         // super.generateOptimizedBoolean(currentScope, codeStream, trueLabel,
239         // falseLabel, valueRequired);
240         // return;
241         // }
242         // Constant cst = condition.constant;
243         // Constant condCst = condition.optimizedBooleanConstant();
244         // boolean needTruePart =
245         // !(((cst != NotAConstant) && (cst.booleanValue() == false))
246         // || ((condCst != NotAConstant) && (condCst.booleanValue() == false)));
247         // boolean needFalsePart =
248         // !(((cst != NotAConstant) && (cst.booleanValue() == true))
249         // || ((condCst != NotAConstant) && (condCst.booleanValue() == true)));
250         //
251         // Label internalFalseLabel, endifLabel = new Label(codeStream);
252         //
253         // // Generate code for the condition
254         // boolean needConditionValue = (cst == NotAConstant) && (condCst ==
255         // NotAConstant);
256         // condition.generateOptimizedBoolean(
257         // currentScope,
258         // codeStream,
259         // null,
260         // internalFalseLabel = new Label(codeStream),
261         // needConditionValue);
262         //
263         // if (trueInitStateIndex != -1) {
264         // codeStream.removeNotDefinitelyAssignedVariables(
265         // currentScope,
266         // trueInitStateIndex);
267         // codeStream.addDefinitelyAssignedVariables(currentScope,
268         // trueInitStateIndex);
269         // }
270         // // Then code generation
271         // if (needTruePart) {
272         // valueIfTrue.generateOptimizedBoolean(currentScope, codeStream, trueLabel,
273         // falseLabel, valueRequired);
274         //                      
275         // if (needFalsePart) {
276         // // Jump over the else part
277         // int position = codeStream.position;
278         // codeStream.goto_(endifLabel);
279         // codeStream.updateLastRecordedEndPC(position);
280         // // No need to decrement codestream stack size
281         // // since valueIfTrue was already consumed by branch bytecode
282         // }
283         // }
284         // if (needFalsePart) {
285         // internalFalseLabel.place();
286         // if (falseInitStateIndex != -1) {
287         // codeStream.removeNotDefinitelyAssignedVariables(
288         // currentScope,
289         // falseInitStateIndex);
290         // codeStream.addDefinitelyAssignedVariables(currentScope,
291         // falseInitStateIndex);
292         // }
293         // valueIfFalse.generateOptimizedBoolean(currentScope, codeStream,
294         // trueLabel, falseLabel, valueRequired);
295         //
296         // // End of if statement
297         // endifLabel.place();
298         // }
299         // // May loose some local variable initializations : affecting the local
300         // variable attributes
301         // if (mergedInitStateIndex != -1) {
302         // codeStream.removeNotDefinitelyAssignedVariables(
303         // currentScope,
304         // mergedInitStateIndex);
305         // }
306         // // no implicit conversion for boolean values
307         // codeStream.updateLastRecordedEndPC(codeStream.position);
308         // }
309         //
310         // public Constant optimizedBooleanConstant() {
311         //
312         // return this.optimizedBooleanConstant == null ? this.constant :
313         // this.optimizedBooleanConstant;
314         // }
315         //      
316         // public TypeBinding resolveType(BlockScope scope) {
317         // // specs p.368
318         // constant = NotAConstant;
319         // TypeBinding conditionType = condition.resolveTypeExpecting(scope,
320         // BooleanBinding);
321         // TypeBinding valueIfTrueType = valueIfTrue.resolveType(scope);
322         // TypeBinding valueIfFalseType = valueIfFalse.resolveType(scope);
323         // if (conditionType == null || valueIfTrueType == null || valueIfFalseType
324         // == null)
325         // return null;
326         //
327         // // Propagate the constant value from the valueIfTrue and valueIFFalse
328         // expression if it is possible
329         // Constant condConstant, trueConstant, falseConstant;
330         // if ((condConstant = condition.constant) != NotAConstant
331         // && (trueConstant = valueIfTrue.constant) != NotAConstant
332         // && (falseConstant = valueIfFalse.constant) != NotAConstant) {
333         // // all terms are constant expression so we can propagate the constant
334         // // from valueIFTrue or valueIfFalse to teh receiver constant
335         // constant = condConstant.booleanValue() ? trueConstant : falseConstant;
336         // }
337         // if (valueIfTrueType == valueIfFalseType) { // harmed the implicit
338         // conversion
339         // valueIfTrue.implicitWidening(valueIfTrueType, valueIfTrueType);
340         // valueIfFalse.implicitConversion = valueIfTrue.implicitConversion;
341         // if (valueIfTrueType == LongBinding || valueIfTrueType == DoubleBinding) {
342         // returnTypeSlotSize = 2;
343         // }
344         //
345         // if (valueIfTrueType == BooleanBinding) {
346         // this.optimizedIfTrueConstant = valueIfTrue.optimizedBooleanConstant();
347         // this.optimizedIfFalseConstant = valueIfFalse.optimizedBooleanConstant();
348         //                      
349         // // Propagate the optimized boolean constant if possible
350         // if ((condConstant = condition.optimizedBooleanConstant()) !=
351         // NotAConstant) {
352         //                                      
353         // this.optimizedBooleanConstant = condConstant.booleanValue()
354         // ? optimizedIfTrueConstant
355         // : optimizedIfFalseConstant;
356         // }
357         // }
358         // return this.resolvedType = valueIfTrueType;
359         // }
360         // // Determine the return type depending on argument types
361         // // Numeric types
362         // if (valueIfTrueType.isNumericType() && valueIfFalseType.isNumericType())
363         // {
364         // // (Short x Byte) or (Byte x Short)"
365         // if ((valueIfTrueType == ByteBinding && valueIfFalseType == ShortBinding)
366         // || (valueIfTrueType == ShortBinding && valueIfFalseType == ByteBinding))
367         // {
368         // valueIfTrue.implicitWidening(ShortBinding, valueIfTrueType);
369         // valueIfFalse.implicitWidening(ShortBinding, valueIfFalseType);
370         // this.resolvedType = ShortBinding;
371         // return ShortBinding;
372         // }
373         // // <Byte|Short|Char> x constant(Int) ---> <Byte|Short|Char> and
374         // reciprocally
375         // if ((valueIfTrueType == ByteBinding || valueIfTrueType == ShortBinding ||
376         // valueIfTrueType == CharBinding)
377         // && (valueIfFalseType == IntBinding
378         // && valueIfFalse.isConstantValueOfTypeAssignableToType(valueIfFalseType,
379         // valueIfTrueType))) {
380         // valueIfTrue.implicitWidening(valueIfTrueType, valueIfTrueType);
381         // valueIfFalse.implicitWidening(valueIfTrueType, valueIfFalseType);
382         // this.resolvedType = valueIfTrueType;
383         // return valueIfTrueType;
384         // }
385         // if ((valueIfFalseType == ByteBinding
386         // || valueIfFalseType == ShortBinding
387         // || valueIfFalseType == CharBinding)
388         // && (valueIfTrueType == IntBinding
389         // && valueIfTrue.isConstantValueOfTypeAssignableToType(valueIfTrueType,
390         // valueIfFalseType))) {
391         // valueIfTrue.implicitWidening(valueIfFalseType, valueIfTrueType);
392         // valueIfFalse.implicitWidening(valueIfFalseType, valueIfFalseType);
393         // this.resolvedType = valueIfFalseType;
394         // return valueIfFalseType;
395         // }
396         // // Manual binary numeric promotion
397         // // int
398         // if (BaseTypeBinding.isNarrowing(valueIfTrueType.id, T_int)
399         // && BaseTypeBinding.isNarrowing(valueIfFalseType.id, T_int)) {
400         // valueIfTrue.implicitWidening(IntBinding, valueIfTrueType);
401         // valueIfFalse.implicitWidening(IntBinding, valueIfFalseType);
402         // this.resolvedType = IntBinding;
403         // return IntBinding;
404         // }
405         // // long
406         // if (BaseTypeBinding.isNarrowing(valueIfTrueType.id, T_long)
407         // && BaseTypeBinding.isNarrowing(valueIfFalseType.id, T_long)) {
408         // valueIfTrue.implicitWidening(LongBinding, valueIfTrueType);
409         // valueIfFalse.implicitWidening(LongBinding, valueIfFalseType);
410         // returnTypeSlotSize = 2;
411         // this.resolvedType = LongBinding;
412         // return LongBinding;
413         // }
414         // // float
415         // if (BaseTypeBinding.isNarrowing(valueIfTrueType.id, T_float)
416         // && BaseTypeBinding.isNarrowing(valueIfFalseType.id, T_float)) {
417         // valueIfTrue.implicitWidening(FloatBinding, valueIfTrueType);
418         // valueIfFalse.implicitWidening(FloatBinding, valueIfFalseType);
419         // this.resolvedType = FloatBinding;
420         // return FloatBinding;
421         // }
422         // // double
423         // valueIfTrue.implicitWidening(DoubleBinding, valueIfTrueType);
424         // valueIfFalse.implicitWidening(DoubleBinding, valueIfFalseType);
425         // returnTypeSlotSize = 2;
426         // this.resolvedType = DoubleBinding;
427         // return DoubleBinding;
428         // }
429         // // Type references (null null is already tested)
430         // if ((valueIfTrueType.isBaseType() && valueIfTrueType != NullBinding)
431         // || (valueIfFalseType.isBaseType() && valueIfFalseType != NullBinding)) {
432         // scope.problemReporter().conditionalArgumentsIncompatibleTypes(
433         // this,
434         // valueIfTrueType,
435         // valueIfFalseType);
436         // return null;
437         // }
438         // if (valueIfFalseType.isCompatibleWith(valueIfTrueType)) {
439         // valueIfTrue.implicitWidening(valueIfTrueType, valueIfTrueType);
440         // valueIfFalse.implicitWidening(valueIfTrueType, valueIfFalseType);
441         // this.resolvedType = valueIfTrueType;
442         // return valueIfTrueType;
443         // }
444         // if (valueIfTrueType.isCompatibleWith(valueIfFalseType)) {
445         // valueIfTrue.implicitWidening(valueIfFalseType, valueIfTrueType);
446         // valueIfFalse.implicitWidening(valueIfFalseType, valueIfFalseType);
447         // this.resolvedType = valueIfFalseType;
448         // return valueIfFalseType;
449         // }
450         // scope.problemReporter().conditionalArgumentsIncompatibleTypes(
451         // this,
452         // valueIfTrueType,
453         // valueIfFalseType);
454         // return null;
455         // }
456         public StringBuffer printExpressionNoParenthesis(int indent,
457                         StringBuffer output) {
458
459                 condition.printExpression(indent, output).append(" ? "); //$NON-NLS-1$
460                 valueIfTrue.printExpression(0, output).append(" : "); //$NON-NLS-1$
461                 return valueIfFalse.printExpression(0, output);
462         }
463
464         public String toStringExpressionNoParenthesis() {
465                 return condition.toStringExpression() + " ? " + //$NON-NLS-1$
466                                 valueIfTrue.toStringExpression() + " : " + //$NON-NLS-1$
467                                 valueIfFalse.toStringExpression();
468         }
469
470         public void traverse(ASTVisitor visitor, BlockScope scope) {
471                 if (visitor.visit(this, scope)) {
472                         condition.traverse(visitor, scope);
473                         valueIfTrue.traverse(visitor, scope);
474                         valueIfFalse.traverse(visitor, scope);
475                 }
476                 visitor.endVisit(this, scope);
477         }
478 }