1) Added missing strings for italic, underline and strike through.
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / compiler / ast / EqualExpression.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.core.compiler.ITerminalSymbols.TokenName;
14 import net.sourceforge.phpdt.internal.compiler.ASTVisitor;
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.impl.Constant;
18 import net.sourceforge.phpdt.internal.compiler.lookup.ArrayBinding;
19 import net.sourceforge.phpdt.internal.compiler.lookup.BlockScope;
20 import net.sourceforge.phpdt.internal.compiler.lookup.MethodBinding;
21 import net.sourceforge.phpdt.internal.compiler.lookup.ReferenceBinding;
22 import net.sourceforge.phpdt.internal.compiler.lookup.Scope;
23 import net.sourceforge.phpdt.internal.compiler.lookup.TypeBinding;
24
25 public class EqualExpression extends BinaryExpression {
26
27         public EqualExpression(Expression left, Expression right, int operator) {
28                 super (left, right, operator);
29         }
30
31         public FlowInfo analyseCode(BlockScope currentScope,
32                         FlowContext flowContext, FlowInfo flowInfo) {
33                 if (((bits & OperatorMASK) >> OperatorSHIFT) == EQUAL_EQUAL) {
34                         if ((left.constant != NotAConstant)
35                                         && (left.constant.typeID() == T_boolean)) {
36                                 if (left.constant.booleanValue()) { // true == anything
37                                         // this is equivalent to the right argument inits
38                                         return right.analyseCode(currentScope, flowContext,
39                                                         flowInfo);
40                                 } else { // false == anything
41                                         // this is equivalent to the right argument inits negated
42                                         return right.analyseCode(currentScope, flowContext,
43                                                         flowInfo).asNegatedCondition();
44                                 }
45                         }
46                         if ((right.constant != NotAConstant)
47                                         && (right.constant.typeID() == T_boolean)) {
48                                 if (right.constant.booleanValue()) { // anything == true
49                                         // this is equivalent to the right argument inits
50                                         return left
51                                                         .analyseCode(currentScope, flowContext, flowInfo);
52                                 } else { // anything == false
53                                         // this is equivalent to the right argument inits negated
54                                         return left
55                                                         .analyseCode(currentScope, flowContext, flowInfo)
56                                                         .asNegatedCondition();
57                                 }
58                         }
59                         return right.analyseCode(
60                                         currentScope,
61                                         flowContext,
62                                         left.analyseCode(currentScope, flowContext, flowInfo)
63                                                         .unconditionalInits()).unconditionalInits();
64                 } else { // NOT_EQUAL :
65                         if ((left.constant != NotAConstant)
66                                         && (left.constant.typeID() == T_boolean)) {
67                                 if (!left.constant.booleanValue()) { // false != anything
68                                         // this is equivalent to the right argument inits
69                                         return right.analyseCode(currentScope, flowContext,
70                                                         flowInfo);
71                                 } else { // true != anything
72                                         // this is equivalent to the right argument inits negated
73                                         return right.analyseCode(currentScope, flowContext,
74                                                         flowInfo).asNegatedCondition();
75                                 }
76                         }
77                         if ((right.constant != NotAConstant)
78                                         && (right.constant.typeID() == T_boolean)) {
79                                 if (!right.constant.booleanValue()) { // anything != false
80                                         // this is equivalent to the right argument inits
81                                         return left
82                                                         .analyseCode(currentScope, flowContext, flowInfo);
83                                 } else { // anything != true
84                                         // this is equivalent to the right argument inits negated
85                                         return left
86                                                         .analyseCode(currentScope, flowContext, flowInfo)
87                                                         .asNegatedCondition();
88                                 }
89                         }
90                         return right.analyseCode(
91                                         currentScope,
92                                         flowContext,
93                                         left.analyseCode(currentScope, flowContext, flowInfo)
94                                                         .unconditionalInits()).asNegatedCondition()
95                                         .unconditionalInits();
96                 }
97         }
98
99         public final boolean areTypesCastCompatible(BlockScope scope,
100                         TypeBinding castType, TypeBinding expressionType) {
101                 // see specifications 5.5
102                 // A more complete version of this method is provided on
103                 // CastExpression (it deals with constant and need runtime checkcast)
104
105                 if (castType == expressionType)
106                         return true;
107
108                 // ========ARRAY===============
109                 if (expressionType.isArrayType()) {
110                         if (castType.isArrayType()) { // ------- (castTb.isArray)
111                                                                                         // expressionTb.isArray -----------
112                                 TypeBinding expressionEltType = ((ArrayBinding) expressionType)
113                                                 .elementsType(scope);
114                                 if (expressionEltType.isBaseType())
115                                         // <---stop the recursion-------
116                                         return ((ArrayBinding) castType).elementsType(scope) == expressionEltType;
117                                 // recursivly on the elts...
118                                 return areTypesCastCompatible(scope, ((ArrayBinding) castType)
119                                                 .elementsType(scope), expressionEltType);
120                         }
121                         if (castType.isBaseType()) {
122                                 return false;
123                         }
124                         if (castType.isClass()) { // ------(castTb.isClass)
125                                                                                 // expressionTb.isArray ---------------
126                                 if (scope.isJavaLangObject(castType))
127                                         return true;
128                                 return false;
129                         }
130                         if (castType.isInterface()) { // ------- (castTb.isInterface)
131                                                                                         // expressionTb.isArray -----------
132                                 if (scope.isJavaLangCloneable(castType)
133                                                 || scope.isJavaIoSerializable(castType)) {
134                                         return true;
135                                 }
136                                 return false;
137                         }
138
139                         return false;
140                 }
141
142                 // ------------(castType) null--------------
143                 if (expressionType == NullBinding) {
144                         return !castType.isBaseType();
145                 }
146
147                 // ========BASETYPE==============
148                 if (expressionType.isBaseType()) {
149                         return false;
150                 }
151
152                 // ========REFERENCE TYPE===================
153
154                 if (expressionType.isClass()) {
155                         if (castType.isArrayType()) { // ---- (castTb.isArray)
156                                                                                         // expressionTb.isClass -------
157                                 if (scope.isJavaLangObject(expressionType))
158                                         return true;
159                         }
160                         if (castType.isBaseType()) {
161                                 return false;
162                         }
163                         if (castType.isClass()) { // ----- (castTb.isClass)
164                                                                                 // expressionTb.isClass ------
165                                 if (expressionType.isCompatibleWith(castType))
166                                         return true;
167                                 else {
168                                         if (castType.isCompatibleWith(expressionType)) {
169                                                 return true;
170                                         }
171                                         return false;
172                                 }
173                         }
174                         if (castType.isInterface()) { // ----- (castTb.isInterface)
175                                                                                         // expressionTb.isClass -------
176                                 if (((ReferenceBinding) expressionType).isFinal()) { // no
177                                                                                                                                                 // subclass
178                                                                                                                                                 // for
179                                                                                                                                                 // expressionTb,
180                                                                                                                                                 // thus
181                                                                                                                                                 // compile-time
182                                                                                                                                                 // check
183                                                                                                                                                 // is
184                                                                                                                                                 // valid
185                                         if (expressionType.isCompatibleWith(castType))
186                                                 return true;
187                                         return false;
188                                 } else {
189                                         return true;
190                                 }
191                         }
192
193                         return false;
194                 }
195                 if (expressionType.isInterface()) {
196                         if (castType.isArrayType()) { // ----- (castTb.isArray)
197                                                                                         // expressionTb.isInterface ------
198                                 if (scope.isJavaLangCloneable(expressionType)
199                                                 || scope.isJavaIoSerializable(expressionType))
200                                 // potential runtime error
201                                 {
202                                         return true;
203                                 }
204                                 return false;
205                         }
206                         if (castType.isBaseType()) {
207                                 return false;
208                         }
209                         if (castType.isClass()) { // ----- (castTb.isClass)
210                                                                                 // expressionTb.isInterface --------
211                                 if (scope.isJavaLangObject(castType))
212                                         return true;
213                                 if (((ReferenceBinding) castType).isFinal()) { // no subclass
214                                                                                                                                 // for castTb,
215                                                                                                                                 // thus
216                                                                                                                                 // compile-time
217                                                                                                                                 // check is
218                                                                                                                                 // valid
219                                         if (castType.isCompatibleWith(expressionType)) {
220                                                 return true;
221                                         }
222                                         return false;
223                                 }
224                                 return true;
225                         }
226                         if (castType.isInterface()) { // ----- (castTb.isInterface)
227                                                                                         // expressionTb.isInterface -------
228                                 if (Scope.compareTypes(castType, expressionType) == NotRelated) {
229                                         MethodBinding[] castTbMethods = ((ReferenceBinding) castType)
230                                                         .methods();
231                                         int castTbMethodsLength = castTbMethods.length;
232                                         MethodBinding[] expressionTbMethods = ((ReferenceBinding) expressionType)
233                                                         .methods();
234                                         int expressionTbMethodsLength = expressionTbMethods.length;
235                                         for (int i = 0; i < castTbMethodsLength; i++) {
236                                                 for (int j = 0; j < expressionTbMethodsLength; j++) {
237                                                         if (castTbMethods[i].selector == expressionTbMethods[j].selector) {
238                                                                 if (castTbMethods[i].returnType != expressionTbMethods[j].returnType) {
239                                                                         if (castTbMethods[i]
240                                                                                         .areParametersEqual(expressionTbMethods[j])) {
241                                                                                 return false;
242                                                                         }
243                                                                 }
244                                                         }
245                                                 }
246                                         }
247                                 }
248                                 return true;
249                         }
250
251                         return false;
252                 }
253
254                 return false;
255         }
256
257         public final void computeConstant(TypeBinding leftType,
258                         TypeBinding rightType) {
259                 if ((this.left.constant != NotAConstant)
260                                 && (this.right.constant != NotAConstant)) {
261                         this.constant = Constant.computeConstantOperationEQUAL_EQUAL(
262                                         left.constant, leftType.id, EQUAL_EQUAL, right.constant,
263                                         rightType.id);
264                         if (((this.bits & OperatorMASK) >> OperatorSHIFT) == NOT_EQUAL)
265                                 constant = Constant.fromValue(!constant.booleanValue());
266                 } else {
267                         this.constant = NotAConstant;
268                         // no optimization for null == null
269                 }
270         }
271
272         /**
273          * Normal == or != code generation.
274          * 
275          * @param currentScope
276          *            net.sourceforge.phpdt.internal.compiler.lookup.BlockScope
277          * @param codeStream
278          *            net.sourceforge.phpdt.internal.compiler.codegen.CodeStream
279          * @param valueRequired
280          *            boolean
281          */
282         // public void generateCode(BlockScope currentScope, CodeStream codeStream,
283         // boolean valueRequired) {
284         //
285         // if (constant != NotAConstant) {
286         // int pc = codeStream.position;
287         // if (valueRequired)
288         // codeStream.generateConstant(constant, implicitConversion);
289         // codeStream.recordPositionsFrom(pc, this.sourceStart);
290         // return;
291         // }
292         // Label falseLabel;
293         // bits |= OnlyValueRequiredMASK;
294         // generateOptimizedBoolean(
295         // currentScope,
296         // codeStream,
297         // null,
298         // falseLabel = new Label(codeStream),
299         // valueRequired);
300         // if (falseLabel.hasForwardReferences()) {
301         // if (valueRequired){
302         // // comparison is TRUE
303         // codeStream.iconst_1();
304         // if ((bits & ValueForReturnMASK) != 0){
305         // codeStream.ireturn();
306         // // comparison is FALSE
307         // falseLabel.place();
308         // codeStream.iconst_0();
309         // } else {
310         // Label endLabel = new Label(codeStream);
311         // codeStream.goto_(endLabel);
312         // codeStream.decrStackSize(1);
313         // // comparison is FALSE
314         // falseLabel.place();
315         // codeStream.iconst_0();
316         // endLabel.place();
317         // }
318         // } else {
319         // falseLabel.place();
320         // }
321         // }
322         // }
323         /**
324          * Boolean operator code generation Optimized operations are: == and !=
325          */
326         // public void generateOptimizedBoolean(BlockScope currentScope, CodeStream
327         // codeStream, Label trueLabel, Label falseLabel, boolean valueRequired) {
328         //
329         // if (constant != Constant.NotAConstant) {
330         // super.generateOptimizedBoolean(currentScope, codeStream, trueLabel,
331         // falseLabel, valueRequired);
332         // return;
333         // }
334         // if (((bits & OperatorMASK) >> OperatorSHIFT) == EQUAL_EQUAL) {
335         // if ((left.implicitConversion & 0xF) /*compile-time*/ == T_boolean) {
336         // generateOptimizedBooleanEqual(currentScope, codeStream, trueLabel,
337         // falseLabel, valueRequired);
338         // } else {
339         // generateOptimizedNonBooleanEqual(currentScope, codeStream, trueLabel,
340         // falseLabel, valueRequired);
341         // }
342         // } else {
343         // if ((left.implicitConversion & 0xF) /*compile-time*/ == T_boolean) {
344         // generateOptimizedBooleanEqual(currentScope, codeStream, falseLabel,
345         // trueLabel, valueRequired);
346         // } else {
347         // generateOptimizedNonBooleanEqual(currentScope, codeStream, falseLabel,
348         // trueLabel, valueRequired);
349         // }
350         // }
351         // }
352         /**
353          * Boolean generation for == with boolean operands
354          * 
355          * Note this code does not optimize conditional constants !!!!
356          */
357         // public void generateOptimizedBooleanEqual(BlockScope currentScope,
358         // CodeStream codeStream, Label trueLabel, Label falseLabel, boolean
359         // valueRequired) {
360         //
361         // // optimized cases: true == x, false == x
362         // if (left.constant != NotAConstant) {
363         // boolean inline = left.constant.booleanValue();
364         // right.generateOptimizedBoolean(currentScope, codeStream, (inline ?
365         // trueLabel : falseLabel), (inline ? falseLabel : trueLabel),
366         // valueRequired);
367         // return;
368         // } // optimized cases: x == true, x == false
369         // if (right.constant != NotAConstant) {
370         // boolean inline = right.constant.booleanValue();
371         // left.generateOptimizedBoolean(currentScope, codeStream, (inline ?
372         // trueLabel : falseLabel), (inline ? falseLabel : trueLabel),
373         // valueRequired);
374         // return;
375         // }
376         // // default case
377         // left.generateCode(currentScope, codeStream, valueRequired);
378         // right.generateCode(currentScope, codeStream, valueRequired);
379         // if (valueRequired) {
380         // if (falseLabel == null) {
381         // if (trueLabel != null) {
382         // // implicit falling through the FALSE case
383         // codeStream.if_icmpeq(trueLabel);
384         // }
385         // } else {
386         // // implicit falling through the TRUE case
387         // if (trueLabel == null) {
388         // codeStream.if_icmpne(falseLabel);
389         // } else {
390         // // no implicit fall through TRUE/FALSE --> should never occur
391         // }
392         // }
393         // }
394         // // reposition the endPC
395         // codeStream.updateLastRecordedEndPC(codeStream.position);
396         // }
397         // /**
398         // * Boolean generation for == with non-boolean operands
399         // *
400         // */
401         // public void generateOptimizedNonBooleanEqual(BlockScope currentScope,
402         // CodeStream codeStream, Label trueLabel, Label falseLabel, boolean
403         // valueRequired) {
404         //
405         // int pc = codeStream.position;
406         // Constant inline;
407         // if ((inline = right.constant) != NotAConstant) {
408         // // optimized case: x == 0
409         // if (((left.implicitConversion >> 4) == T_int) && (inline.intValue() ==
410         // 0)) {
411         // left.generateCode(currentScope, codeStream, valueRequired);
412         // if (valueRequired) {
413         // if (falseLabel == null) {
414         // if (trueLabel != null) {
415         // // implicit falling through the FALSE case
416         // codeStream.ifeq(trueLabel);
417         // }
418         // } else {
419         // // implicit falling through the TRUE case
420         // if (trueLabel == null) {
421         // codeStream.ifne(falseLabel);
422         // } else {
423         // // no implicit fall through TRUE/FALSE --> should never occur
424         // }
425         // }
426         // }
427         // codeStream.recordPositionsFrom(pc, this.sourceStart);
428         // return;
429         // }
430         // }
431         // if ((inline = left.constant) != NotAConstant) {
432         // // optimized case: 0 == x
433         // if (((left.implicitConversion >> 4) == T_int)
434         // && (inline.intValue() == 0)) {
435         // right.generateCode(currentScope, codeStream, valueRequired);
436         // if (valueRequired) {
437         // if (falseLabel == null) {
438         // if (trueLabel != null) {
439         // // implicit falling through the FALSE case
440         // codeStream.ifeq(trueLabel);
441         // }
442         // } else {
443         // // implicit falling through the TRUE case
444         // if (trueLabel == null) {
445         // codeStream.ifne(falseLabel);
446         // } else {
447         // // no implicit fall through TRUE/FALSE --> should never occur
448         // }
449         // }
450         // }
451         // codeStream.recordPositionsFrom(pc, this.sourceStart);
452         // return;
453         // }
454         // }
455         // // null cases
456         // // optimized case: x == null
457         // if (right instanceof NullLiteral) {
458         // if (left instanceof NullLiteral) {
459         // // null == null
460         // if (valueRequired) {
461         // if ((bits & OnlyValueRequiredMASK) != 0) {
462         // if (((bits & OperatorMASK) >> OperatorSHIFT) == EQUAL_EQUAL) {
463         // codeStream.iconst_1();
464         // } else {
465         // codeStream.iconst_0();
466         // }
467         // } else {
468         // if (falseLabel == null) {
469         // // implicit falling through the FALSE case
470         // if (trueLabel != null) {
471         // codeStream.goto_(trueLabel);
472         // }
473         // }
474         // }
475         // }
476         // } else {
477         // left.generateCode(currentScope, codeStream, valueRequired);
478         // if (valueRequired) {
479         // if (falseLabel == null) {
480         // if (trueLabel != null) {
481         // // implicit falling through the FALSE case
482         // codeStream.ifnull(trueLabel);
483         // }
484         // } else {
485         // // implicit falling through the TRUE case
486         // if (trueLabel == null) {
487         // codeStream.ifnonnull(falseLabel);
488         // } else {
489         // // no implicit fall through TRUE/FALSE --> should never occur
490         // }
491         // }
492         // }
493         // }
494         // codeStream.recordPositionsFrom(pc, this.sourceStart);
495         // return;
496         // } else if (left instanceof NullLiteral) { // optimized case: null == x
497         // right.generateCode(currentScope, codeStream, valueRequired);
498         // if (valueRequired) {
499         // if (falseLabel == null) {
500         // if (trueLabel != null) {
501         // // implicit falling through the FALSE case
502         // codeStream.ifnull(trueLabel);
503         // }
504         // } else {
505         // // implicit falling through the TRUE case
506         // if (trueLabel == null) {
507         // codeStream.ifnonnull(falseLabel);
508         // } else {
509         // // no implicit fall through TRUE/FALSE --> should never occur
510         // }
511         // }
512         // }
513         // codeStream.recordPositionsFrom(pc, this.sourceStart);
514         // return;
515         // }
516         //
517         // // default case
518         // left.generateCode(currentScope, codeStream, valueRequired);
519         // right.generateCode(currentScope, codeStream, valueRequired);
520         // if (valueRequired) {
521         // if (falseLabel == null) {
522         // if (trueLabel != null) {
523         // // implicit falling through the FALSE case
524         // switch (left.implicitConversion >> 4) { // operand runtime type
525         // case T_int :
526         // codeStream.if_icmpeq(trueLabel);
527         // break;
528         // case T_float :
529         // codeStream.fcmpl();
530         // codeStream.ifeq(trueLabel);
531         // break;
532         // case T_long :
533         // codeStream.lcmp();
534         // codeStream.ifeq(trueLabel);
535         // break;
536         // case T_double :
537         // codeStream.dcmpl();
538         // codeStream.ifeq(trueLabel);
539         // break;
540         // default :
541         // codeStream.if_acmpeq(trueLabel);
542         // }
543         // }
544         // } else {
545         // // implicit falling through the TRUE case
546         // if (trueLabel == null) {
547         // switch (left.implicitConversion >> 4) { // operand runtime type
548         // case T_int :
549         // codeStream.if_icmpne(falseLabel);
550         // break;
551         // case T_float :
552         // codeStream.fcmpl();
553         // codeStream.ifne(falseLabel);
554         // break;
555         // case T_long :
556         // codeStream.lcmp();
557         // codeStream.ifne(falseLabel);
558         // break;
559         // case T_double :
560         // codeStream.dcmpl();
561         // codeStream.ifne(falseLabel);
562         // break;
563         // default :
564         // codeStream.if_acmpne(falseLabel);
565         // }
566         // } else {
567         // // no implicit fall through TRUE/FALSE --> should never occur
568         // }
569         // }
570         // }
571         // codeStream.recordPositionsFrom(pc, this.sourceStart);
572         // }
573         public boolean isCompactableOperation() {
574                 return false;
575         }
576
577         public TypeBinding resolveType(BlockScope scope) {
578                 // always return BooleanBinding
579                 TypeBinding leftType = left.resolveType(scope);
580                 TypeBinding rightType = right.resolveType(scope);
581                 if (leftType == null || rightType == null) {
582                         constant = NotAConstant;
583                         return null;
584                 }
585
586                 // both base type
587                 if (leftType.isBaseType() && rightType.isBaseType()) {
588                         // the code is an int
589                         // (cast) left == (cast) rigth --> result
590                         // 0000 0000 0000 0000 0000
591                         // <<16 <<12 <<8 <<4 <<0
592                         int result = ResolveTypeTables[EQUAL_EQUAL][(leftType.id << 4)
593                                         + rightType.id];
594                         left.implicitConversion = result >>> 12;
595                         right.implicitConversion = (result >>> 4) & 0x000FF;
596                         bits |= result & 0xF;
597                         if ((result & 0x0000F) == T_undefined) {
598                                 constant = Constant.NotAConstant;
599                                 scope.problemReporter().invalidOperator(this, leftType,
600                                                 rightType);
601                                 return null;
602                         }
603                         computeConstant(leftType, rightType);
604                         this.resolvedType = BooleanBinding;
605                         return BooleanBinding;
606                 }
607
608                 // Object references
609                 // spec 15.20.3
610                 if (areTypesCastCompatible(scope, rightType, leftType)
611                                 || areTypesCastCompatible(scope, leftType, rightType)) {
612                         // (special case for String)
613                         if ((rightType.id == T_String) && (leftType.id == T_String))
614                                 computeConstant(leftType, rightType);
615                         else
616                                 constant = NotAConstant;
617                         if (rightType.id == T_String)
618                                 right.implicitConversion = String2String;
619                         if (leftType.id == T_String)
620                                 left.implicitConversion = String2String;
621                         this.resolvedType = BooleanBinding;
622                         return BooleanBinding;
623                 }
624                 constant = NotAConstant;
625                 scope.problemReporter().notCompatibleTypesError(this, leftType,
626                                 rightType);
627                 return null;
628         }
629
630         public void traverse(ASTVisitor visitor, BlockScope scope) {
631                 if (visitor.visit(this, scope)) {
632                         left.traverse(visitor, scope);
633                         right.traverse(visitor, scope);
634                 }
635                 visitor.endVisit(this, scope);
636         }
637 }