Change Eclipse-LazyStart: true to Bundle-ActivationPolicy: lazy (upgrade to The Equin...
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / compiler / ast / BinaryExpression.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.impl.Constant;
17 import net.sourceforge.phpdt.internal.compiler.lookup.ArrayBinding;
18 import net.sourceforge.phpdt.internal.compiler.lookup.BlockScope;
19 import net.sourceforge.phpdt.internal.compiler.lookup.TypeBinding;
20
21 public class BinaryExpression extends OperatorExpression {
22
23         public Expression left, right;
24
25         public Constant optimizedBooleanConstant;
26
27         public BinaryExpression(Expression left, Expression right, int operator) {
28
29                 this.left = left;
30                 this.right = right;
31                 this.bits |= operator << OperatorSHIFT; // encode operator
32                 this.sourceStart = left.sourceStart;
33                 this.sourceEnd = right.sourceEnd;
34         }
35
36         public FlowInfo analyseCode(BlockScope currentScope,
37                         FlowContext flowContext, FlowInfo flowInfo) {
38
39                 return right.analyseCode(
40                                 currentScope,
41                                 flowContext,
42                                 left.analyseCode(currentScope, flowContext, flowInfo)
43                                                 .unconditionalInits()).unconditionalInits();
44         }
45
46         public void computeConstant(BlockScope scope, int leftId, int rightId) {
47
48                 // compute the constant when valid
49                 if ((this.left.constant != Constant.NotAConstant)
50                                 && (this.right.constant != Constant.NotAConstant)) {
51                         try {
52                                 this.constant = Constant.computeConstantOperation(
53                                                 this.left.constant, leftId,
54                                                 (this.bits & OperatorMASK) >> OperatorSHIFT,
55                                                 this.right.constant, rightId);
56                         } catch (ArithmeticException e) {
57                                 this.constant = Constant.NotAConstant;
58                                 // 1.2 no longer throws an exception at compile-time
59                                 // scope.problemReporter().compileTimeConstantThrowsArithmeticException(this);
60                         }
61                 } else {
62                         this.constant = Constant.NotAConstant;
63                         // add some work for the boolean operators & |
64                         // this.optimizedBooleanConstant(
65                         // leftId,
66                         // (this.bits & OperatorMASK) >> OperatorSHIFT,
67                         // rightId);
68                 }
69         }
70
71         public Constant optimizedBooleanConstant() {
72
73                 return this.optimizedBooleanConstant == null ? this.constant
74                                 : this.optimizedBooleanConstant;
75         }
76
77         /**
78          * Code generation for a binary operation
79          */
80         // public void generateCode(
81         // BlockScope currentScope,
82         // CodeStream codeStream,
83         // boolean valueRequired) {
84         //
85         // int pc = codeStream.position;
86         // Label falseLabel, endLabel;
87         // if (constant != Constant.NotAConstant) {
88         // if (valueRequired)
89         // codeStream.generateConstant(constant, implicitConversion);
90         // codeStream.recordPositionsFrom(pc, this.sourceStart);
91         // return;
92         // }
93         // bits |= OnlyValueRequiredMASK;
94         // switch ((bits & OperatorMASK) >> OperatorSHIFT) {
95         // case PLUS :
96         // switch (bits & ReturnTypeIDMASK) {
97         // case T_String :
98         // codeStream.generateStringAppend(currentScope, left, right);
99         // if (!valueRequired)
100         // codeStream.pop();
101         // break;
102         // case T_int :
103         // left.generateCode(currentScope, codeStream, valueRequired);
104         // right.generateCode(currentScope, codeStream, valueRequired);
105         // if (valueRequired)
106         // codeStream.iadd();
107         // break;
108         // case T_long :
109         // left.generateCode(currentScope, codeStream, valueRequired);
110         // right.generateCode(currentScope, codeStream, valueRequired);
111         // if (valueRequired)
112         // codeStream.ladd();
113         // break;
114         // case T_double :
115         // left.generateCode(currentScope, codeStream, valueRequired);
116         // right.generateCode(currentScope, codeStream, valueRequired);
117         // if (valueRequired)
118         // codeStream.dadd();
119         // break;
120         // case T_float :
121         // left.generateCode(currentScope, codeStream, valueRequired);
122         // right.generateCode(currentScope, codeStream, valueRequired);
123         // if (valueRequired)
124         // codeStream.fadd();
125         // break;
126         // }
127         // break;
128         // case MINUS :
129         // switch (bits & ReturnTypeIDMASK) {
130         // case T_int :
131         // left.generateCode(currentScope, codeStream, valueRequired);
132         // right.generateCode(currentScope, codeStream, valueRequired);
133         // if (valueRequired)
134         // codeStream.isub();
135         // break;
136         // case T_long :
137         // left.generateCode(currentScope, codeStream, valueRequired);
138         // right.generateCode(currentScope, codeStream, valueRequired);
139         // if (valueRequired)
140         // codeStream.lsub();
141         // break;
142         // case T_double :
143         // left.generateCode(currentScope, codeStream, valueRequired);
144         // right.generateCode(currentScope, codeStream, valueRequired);
145         // if (valueRequired)
146         // codeStream.dsub();
147         // break;
148         // case T_float :
149         // left.generateCode(currentScope, codeStream, valueRequired);
150         // right.generateCode(currentScope, codeStream, valueRequired);
151         // if (valueRequired)
152         // codeStream.fsub();
153         // break;
154         // }
155         // break;
156         // case MULTIPLY :
157         // switch (bits & ReturnTypeIDMASK) {
158         // case T_int :
159         // left.generateCode(currentScope, codeStream, valueRequired);
160         // right.generateCode(currentScope, codeStream, valueRequired);
161         // if (valueRequired)
162         // codeStream.imul();
163         // break;
164         // case T_long :
165         // left.generateCode(currentScope, codeStream, valueRequired);
166         // right.generateCode(currentScope, codeStream, valueRequired);
167         // if (valueRequired)
168         // codeStream.lmul();
169         // break;
170         // case T_double :
171         // left.generateCode(currentScope, codeStream, valueRequired);
172         // right.generateCode(currentScope, codeStream, valueRequired);
173         // if (valueRequired)
174         // codeStream.dmul();
175         // break;
176         // case T_float :
177         // left.generateCode(currentScope, codeStream, valueRequired);
178         // right.generateCode(currentScope, codeStream, valueRequired);
179         // if (valueRequired)
180         // codeStream.fmul();
181         // break;
182         // }
183         // break;
184         // case DIVIDE :
185         // switch (bits & ReturnTypeIDMASK) {
186         // case T_int :
187         // left.generateCode(currentScope, codeStream, true);
188         // right.generateCode(currentScope, codeStream, true);
189         // codeStream.idiv();
190         // if (!valueRequired)
191         // codeStream.pop();
192         // break;
193         // case T_long :
194         // left.generateCode(currentScope, codeStream, true);
195         // right.generateCode(currentScope, codeStream, true);
196         // codeStream.ldiv();
197         // if (!valueRequired)
198         // codeStream.pop2();
199         // break;
200         // case T_double :
201         // left.generateCode(currentScope, codeStream, valueRequired);
202         // right.generateCode(currentScope, codeStream, valueRequired);
203         // if (valueRequired)
204         // codeStream.ddiv();
205         // break;
206         // case T_float :
207         // left.generateCode(currentScope, codeStream, valueRequired);
208         // right.generateCode(currentScope, codeStream, valueRequired);
209         // if (valueRequired)
210         // codeStream.fdiv();
211         // break;
212         // }
213         // break;
214         // case REMAINDER :
215         // switch (bits & ReturnTypeIDMASK) {
216         // case T_int :
217         // left.generateCode(currentScope, codeStream, true);
218         // right.generateCode(currentScope, codeStream, true);
219         // codeStream.irem();
220         // if (!valueRequired)
221         // codeStream.pop();
222         // break;
223         // case T_long :
224         // left.generateCode(currentScope, codeStream, true);
225         // right.generateCode(currentScope, codeStream, true);
226         // codeStream.lrem();
227         // if (!valueRequired)
228         // codeStream.pop2();
229         // break;
230         // case T_double :
231         // left.generateCode(currentScope, codeStream, valueRequired);
232         // right.generateCode(currentScope, codeStream, valueRequired);
233         // if (valueRequired)
234         // codeStream.drem();
235         // break;
236         // case T_float :
237         // left.generateCode(currentScope, codeStream, valueRequired);
238         // right.generateCode(currentScope, codeStream, valueRequired);
239         // if (valueRequired)
240         // codeStream.frem();
241         // break;
242         // }
243         // break;
244         // case AND :
245         // switch (bits & ReturnTypeIDMASK) {
246         // case T_int :
247         // // 0 & x
248         // if ((left.constant != Constant.NotAConstant)
249         // && (left.constant.typeID() == T_int)
250         // && (left.constant.intValue() == 0)) {
251         // right.generateCode(currentScope, codeStream, false);
252         // if (valueRequired)
253         // codeStream.iconst_0();
254         // } else {
255         // // x & 0
256         // if ((right.constant != Constant.NotAConstant)
257         // && (right.constant.typeID() == T_int)
258         // && (right.constant.intValue() == 0)) {
259         // left.generateCode(currentScope, codeStream, false);
260         // if (valueRequired)
261         // codeStream.iconst_0();
262         // } else {
263         // left.generateCode(currentScope, codeStream, valueRequired);
264         // right.generateCode(currentScope, codeStream, valueRequired);
265         // if (valueRequired)
266         // codeStream.iand();
267         // }
268         // }
269         // break;
270         // case T_long :
271         // // 0 & x
272         // if ((left.constant != Constant.NotAConstant)
273         // && (left.constant.typeID() == T_long)
274         // && (left.constant.longValue() == 0L)) {
275         // right.generateCode(currentScope, codeStream, false);
276         // if (valueRequired)
277         // codeStream.lconst_0();
278         // } else {
279         // // x & 0
280         // if ((right.constant != Constant.NotAConstant)
281         // && (right.constant.typeID() == T_long)
282         // && (right.constant.longValue() == 0L)) {
283         // left.generateCode(currentScope, codeStream, false);
284         // if (valueRequired)
285         // codeStream.lconst_0();
286         // } else {
287         // left.generateCode(currentScope, codeStream, valueRequired);
288         // right.generateCode(currentScope, codeStream, valueRequired);
289         // if (valueRequired)
290         // codeStream.land();
291         // }
292         // }
293         // break;
294         // case T_boolean : // logical and
295         // generateOptimizedLogicalAnd(
296         // currentScope,
297         // codeStream,
298         // null,
299         // (falseLabel = new Label(codeStream)),
300         // valueRequired);
301         // /* improving code gen for such a case: boolean b = i < 0 && false;
302         // * since the label has never been used, we have the inlined value on the
303         // stack. */
304         // if (falseLabel.hasForwardReferences()) {
305         // if (valueRequired) {
306         // codeStream.iconst_1();
307         // if ((bits & ValueForReturnMASK) != 0) {
308         // codeStream.ireturn();
309         // falseLabel.place();
310         // codeStream.iconst_0();
311         // } else {
312         // codeStream.goto_(endLabel = new Label(codeStream));
313         // codeStream.decrStackSize(1);
314         // falseLabel.place();
315         // codeStream.iconst_0();
316         // endLabel.place();
317         // }
318         // } else {
319         // falseLabel.place();
320         // }
321         // }
322         // }
323         // break;
324         // case OR :
325         // switch (bits & ReturnTypeIDMASK) {
326         // case T_int :
327         // // 0 | x
328         // if ((left.constant != Constant.NotAConstant)
329         // && (left.constant.typeID() == T_int)
330         // && (left.constant.intValue() == 0)) {
331         // right.generateCode(currentScope, codeStream, valueRequired);
332         // } else {
333         // // x | 0
334         // if ((right.constant != Constant.NotAConstant)
335         // && (right.constant.typeID() == T_int)
336         // && (right.constant.intValue() == 0)) {
337         // left.generateCode(currentScope, codeStream, valueRequired);
338         // } else {
339         // left.generateCode(currentScope, codeStream, valueRequired);
340         // right.generateCode(currentScope, codeStream, valueRequired);
341         // if (valueRequired)
342         // codeStream.ior();
343         // }
344         // }
345         // break;
346         // case T_long :
347         // // 0 | x
348         // if ((left.constant != Constant.NotAConstant)
349         // && (left.constant.typeID() == T_long)
350         // && (left.constant.longValue() == 0L)) {
351         // right.generateCode(currentScope, codeStream, valueRequired);
352         // } else {
353         // // x | 0
354         // if ((right.constant != Constant.NotAConstant)
355         // && (right.constant.typeID() == T_long)
356         // && (right.constant.longValue() == 0L)) {
357         // left.generateCode(currentScope, codeStream, valueRequired);
358         // } else {
359         // left.generateCode(currentScope, codeStream, valueRequired);
360         // right.generateCode(currentScope, codeStream, valueRequired);
361         // if (valueRequired)
362         // codeStream.lor();
363         // }
364         // }
365         // break;
366         // case T_boolean : // logical or
367         // generateOptimizedLogicalOr(
368         // currentScope,
369         // codeStream,
370         // null,
371         // (falseLabel = new Label(codeStream)),
372         // valueRequired);
373         // /* improving code gen for such a case: boolean b = i < 0 || true;
374         // * since the label has never been used, we have the inlined value on the
375         // stack. */
376         // if (falseLabel.hasForwardReferences()) {
377         // if (valueRequired) {
378         // codeStream.iconst_1();
379         // if ((bits & ValueForReturnMASK) != 0) {
380         // codeStream.ireturn();
381         // falseLabel.place();
382         // codeStream.iconst_0();
383         // } else {
384         // codeStream.goto_(endLabel = new Label(codeStream));
385         // codeStream.decrStackSize(1);
386         // falseLabel.place();
387         // codeStream.iconst_0();
388         // endLabel.place();
389         // }
390         // } else {
391         // falseLabel.place();
392         // }
393         // }
394         // }
395         // break;
396         // case XOR :
397         // switch (bits & ReturnTypeIDMASK) {
398         // case T_int :
399         // // 0 ^ x
400         // if ((left.constant != Constant.NotAConstant)
401         // && (left.constant.typeID() == T_int)
402         // && (left.constant.intValue() == 0)) {
403         // right.generateCode(currentScope, codeStream, valueRequired);
404         // } else {
405         // // x ^ 0
406         // if ((right.constant != Constant.NotAConstant)
407         // && (right.constant.typeID() == T_int)
408         // && (right.constant.intValue() == 0)) {
409         // left.generateCode(currentScope, codeStream, valueRequired);
410         // } else {
411         // left.generateCode(currentScope, codeStream, valueRequired);
412         // right.generateCode(currentScope, codeStream, valueRequired);
413         // if (valueRequired)
414         // codeStream.ixor();
415         // }
416         // }
417         // break;
418         // case T_long :
419         // // 0 ^ x
420         // if ((left.constant != Constant.NotAConstant)
421         // && (left.constant.typeID() == T_long)
422         // && (left.constant.longValue() == 0L)) {
423         // right.generateCode(currentScope, codeStream, valueRequired);
424         // } else {
425         // // x ^ 0
426         // if ((right.constant != Constant.NotAConstant)
427         // && (right.constant.typeID() == T_long)
428         // && (right.constant.longValue() == 0L)) {
429         // left.generateCode(currentScope, codeStream, valueRequired);
430         // } else {
431         // left.generateCode(currentScope, codeStream, valueRequired);
432         // right.generateCode(currentScope, codeStream, valueRequired);
433         // if (valueRequired)
434         // codeStream.lxor();
435         // }
436         // }
437         // break;
438         // case T_boolean :
439         // generateOptimizedLogicalXor(
440         // currentScope,
441         // codeStream,
442         // null,
443         // (falseLabel = new Label(codeStream)),
444         // valueRequired);
445         // /* improving code gen for such a case: boolean b = i < 0 ^ bool;
446         // * since the label has never been used, we have the inlined value on the
447         // stack. */
448         // if (falseLabel.hasForwardReferences()) {
449         // if (valueRequired) {
450         // codeStream.iconst_1();
451         // if ((bits & ValueForReturnMASK) != 0) {
452         // codeStream.ireturn();
453         // falseLabel.place();
454         // codeStream.iconst_0();
455         // } else {
456         // codeStream.goto_(endLabel = new Label(codeStream));
457         // codeStream.decrStackSize(1);
458         // falseLabel.place();
459         // codeStream.iconst_0();
460         // endLabel.place();
461         // }
462         // } else {
463         // falseLabel.place();
464         // }
465         // }
466         // }
467         // break;
468         // case LEFT_SHIFT :
469         // switch (bits & ReturnTypeIDMASK) {
470         // case T_int :
471         // left.generateCode(currentScope, codeStream, valueRequired);
472         // right.generateCode(currentScope, codeStream, valueRequired);
473         // if (valueRequired)
474         // codeStream.ishl();
475         // break;
476         // case T_long :
477         // left.generateCode(currentScope, codeStream, valueRequired);
478         // right.generateCode(currentScope, codeStream, valueRequired);
479         // if (valueRequired)
480         // codeStream.lshl();
481         // }
482         // break;
483         // case RIGHT_SHIFT :
484         // switch (bits & ReturnTypeIDMASK) {
485         // case T_int :
486         // left.generateCode(currentScope, codeStream, valueRequired);
487         // right.generateCode(currentScope, codeStream, valueRequired);
488         // if (valueRequired)
489         // codeStream.ishr();
490         // break;
491         // case T_long :
492         // left.generateCode(currentScope, codeStream, valueRequired);
493         // right.generateCode(currentScope, codeStream, valueRequired);
494         // if (valueRequired)
495         // codeStream.lshr();
496         // }
497         // break;
498         // case UNSIGNED_RIGHT_SHIFT :
499         // switch (bits & ReturnTypeIDMASK) {
500         // case T_int :
501         // left.generateCode(currentScope, codeStream, valueRequired);
502         // right.generateCode(currentScope, codeStream, valueRequired);
503         // if (valueRequired)
504         // codeStream.iushr();
505         // break;
506         // case T_long :
507         // left.generateCode(currentScope, codeStream, valueRequired);
508         // right.generateCode(currentScope, codeStream, valueRequired);
509         // if (valueRequired)
510         // codeStream.lushr();
511         // }
512         // break;
513         // case GREATER :
514         // generateOptimizedGreaterThan(
515         // currentScope,
516         // codeStream,
517         // null,
518         // (falseLabel = new Label(codeStream)),
519         // valueRequired);
520         // if (valueRequired) {
521         // codeStream.iconst_1();
522         // if ((bits & ValueForReturnMASK) != 0) {
523         // codeStream.ireturn();
524         // falseLabel.place();
525         // codeStream.iconst_0();
526         // } else {
527         // codeStream.goto_(endLabel = new Label(codeStream));
528         // codeStream.decrStackSize(1);
529         // falseLabel.place();
530         // codeStream.iconst_0();
531         // endLabel.place();
532         // }
533         // }
534         // break;
535         // case GREATER_EQUAL :
536         // generateOptimizedGreaterThanOrEqual(
537         // currentScope,
538         // codeStream,
539         // null,
540         // (falseLabel = new Label(codeStream)),
541         // valueRequired);
542         // if (valueRequired) {
543         // codeStream.iconst_1();
544         // if ((bits & ValueForReturnMASK) != 0) {
545         // codeStream.ireturn();
546         // falseLabel.place();
547         // codeStream.iconst_0();
548         // } else {
549         // codeStream.goto_(endLabel = new Label(codeStream));
550         // codeStream.decrStackSize(1);
551         // falseLabel.place();
552         // codeStream.iconst_0();
553         // endLabel.place();
554         // }
555         // }
556         // break;
557         // case LESS :
558         // generateOptimizedLessThan(
559         // currentScope,
560         // codeStream,
561         // null,
562         // (falseLabel = new Label(codeStream)),
563         // valueRequired);
564         // if (valueRequired) {
565         // codeStream.iconst_1();
566         // if ((bits & ValueForReturnMASK) != 0) {
567         // codeStream.ireturn();
568         // falseLabel.place();
569         // codeStream.iconst_0();
570         // } else {
571         // codeStream.goto_(endLabel = new Label(codeStream));
572         // codeStream.decrStackSize(1);
573         // falseLabel.place();
574         // codeStream.iconst_0();
575         // endLabel.place();
576         // }
577         // }
578         // break;
579         // case LESS_EQUAL :
580         // generateOptimizedLessThanOrEqual(
581         // currentScope,
582         // codeStream,
583         // null,
584         // (falseLabel = new Label(codeStream)),
585         // valueRequired);
586         // if (valueRequired) {
587         // codeStream.iconst_1();
588         // if ((bits & ValueForReturnMASK) != 0) {
589         // codeStream.ireturn();
590         // falseLabel.place();
591         // codeStream.iconst_0();
592         // } else {
593         // codeStream.goto_(endLabel = new Label(codeStream));
594         // codeStream.decrStackSize(1);
595         // falseLabel.place();
596         // codeStream.iconst_0();
597         // endLabel.place();
598         // }
599         // }
600         // }
601         // if (valueRequired) {
602         // codeStream.generateImplicitConversion(implicitConversion);
603         // }
604         // codeStream.recordPositionsFrom(pc, this.sourceStart);
605         // }
606         /**
607          * Boolean operator code generation Optimized operations are: <, <=, >, >=, &, |, ^
608          */
609         // public void generateOptimizedBoolean(
610         // BlockScope currentScope,
611         // CodeStream codeStream,
612         // Label trueLabel,
613         // Label falseLabel,
614         // boolean valueRequired) {
615         //
616         // if ((constant != Constant.NotAConstant) && (constant.typeID() ==
617         // T_boolean)) {
618         // super.generateOptimizedBoolean(
619         // currentScope,
620         // codeStream,
621         // trueLabel,
622         // falseLabel,
623         // valueRequired);
624         // return;
625         // }
626         // switch ((bits & OperatorMASK) >> OperatorSHIFT) {
627         // case LESS :
628         // generateOptimizedLessThan(
629         // currentScope,
630         // codeStream,
631         // trueLabel,
632         // falseLabel,
633         // valueRequired);
634         // return;
635         // case LESS_EQUAL :
636         // generateOptimizedLessThanOrEqual(
637         // currentScope,
638         // codeStream,
639         // trueLabel,
640         // falseLabel,
641         // valueRequired);
642         // return;
643         // case GREATER :
644         // generateOptimizedGreaterThan(
645         // currentScope,
646         // codeStream,
647         // trueLabel,
648         // falseLabel,
649         // valueRequired);
650         // return;
651         // case GREATER_EQUAL :
652         // generateOptimizedGreaterThanOrEqual(
653         // currentScope,
654         // codeStream,
655         // trueLabel,
656         // falseLabel,
657         // valueRequired);
658         // return;
659         // case AND :
660         // generateOptimizedLogicalAnd(
661         // currentScope,
662         // codeStream,
663         // trueLabel,
664         // falseLabel,
665         // valueRequired);
666         // return;
667         // case OR :
668         // generateOptimizedLogicalOr(
669         // currentScope,
670         // codeStream,
671         // trueLabel,
672         // falseLabel,
673         // valueRequired);
674         // return;
675         // case XOR :
676         // generateOptimizedLogicalXor(
677         // currentScope,
678         // codeStream,
679         // trueLabel,
680         // falseLabel,
681         // valueRequired);
682         // return;
683         // }
684         // super.generateOptimizedBoolean(
685         // currentScope,
686         // codeStream,
687         // trueLabel,
688         // falseLabel,
689         // valueRequired);
690         // }
691         //
692         // /**
693         // * Boolean generation for >
694         // */
695         // public void generateOptimizedGreaterThan(
696         // BlockScope currentScope,
697         // CodeStream codeStream,
698         // Label trueLabel,
699         // Label falseLabel,
700         // boolean valueRequired) {
701         //
702         // int promotedTypeID = left.implicitConversion >> 4;
703         // // both sides got promoted in the same way
704         // if (promotedTypeID == T_int) {
705         // // 0 > x
706         // if ((left.constant != NotAConstant) && (left.constant.intValue() == 0)) {
707         // right.generateCode(currentScope, codeStream, valueRequired);
708         // if (valueRequired) {
709         // if (falseLabel == null) {
710         // if (trueLabel != null) {
711         // // implicitly falling through the FALSE case
712         // codeStream.iflt(trueLabel);
713         // }
714         // } else {
715         // if (trueLabel == null) {
716         // // implicitly falling through the TRUE case
717         // codeStream.ifge(falseLabel);
718         // } else {
719         // // no implicit fall through TRUE/FALSE --> should never occur
720         // }
721         // }
722         // }
723         // // reposition the endPC
724         // codeStream.updateLastRecordedEndPC(codeStream.position);
725         // return;
726         // }
727         // // x > 0
728         // if ((right.constant != NotAConstant) && (right.constant.intValue() == 0))
729         // {
730         // left.generateCode(currentScope, codeStream, valueRequired);
731         // if (valueRequired) {
732         // if (falseLabel == null) {
733         // if (trueLabel != null) {
734         // // implicitly falling through the FALSE case
735         // codeStream.ifgt(trueLabel);
736         // }
737         // } else {
738         // if (trueLabel == null) {
739         // // implicitly falling through the TRUE case
740         // codeStream.ifle(falseLabel);
741         // } else {
742         // // no implicit fall through TRUE/FALSE --> should never occur
743         // }
744         // }
745         // }
746         // // reposition the endPC
747         // codeStream.updateLastRecordedEndPC(codeStream.position);
748         // return;
749         // }
750         // }
751         // // default comparison
752         // left.generateCode(currentScope, codeStream, valueRequired);
753         // right.generateCode(currentScope, codeStream, valueRequired);
754         // if (valueRequired) {
755         // if (falseLabel == null) {
756         // if (trueLabel != null) {
757         // // implicit falling through the FALSE case
758         // switch (promotedTypeID) {
759         // case T_int :
760         // codeStream.if_icmpgt(trueLabel);
761         // break;
762         // case T_float :
763         // codeStream.fcmpl();
764         // codeStream.ifgt(trueLabel);
765         // break;
766         // case T_long :
767         // codeStream.lcmp();
768         // codeStream.ifgt(trueLabel);
769         // break;
770         // case T_double :
771         // codeStream.dcmpl();
772         // codeStream.ifgt(trueLabel);
773         // }
774         // // reposition the endPC
775         // codeStream.updateLastRecordedEndPC(codeStream.position);
776         // return;
777         // }
778         // } else {
779         // if (trueLabel == null) {
780         // // implicit falling through the TRUE case
781         // switch (promotedTypeID) {
782         // case T_int :
783         // codeStream.if_icmple(falseLabel);
784         // break;
785         // case T_float :
786         // codeStream.fcmpl();
787         // codeStream.ifle(falseLabel);
788         // break;
789         // case T_long :
790         // codeStream.lcmp();
791         // codeStream.ifle(falseLabel);
792         // break;
793         // case T_double :
794         // codeStream.dcmpl();
795         // codeStream.ifle(falseLabel);
796         // }
797         // // reposition the endPC
798         // codeStream.updateLastRecordedEndPC(codeStream.position);
799         // return;
800         // } else {
801         // // no implicit fall through TRUE/FALSE --> should never occur
802         // }
803         // }
804         // }
805         // }
806         /**
807          * Boolean generation for >=
808          */
809         // public void generateOptimizedGreaterThanOrEqual(
810         // BlockScope currentScope,
811         // CodeStream codeStream,
812         // Label trueLabel,
813         // Label falseLabel,
814         // boolean valueRequired) {
815         //
816         // int promotedTypeID = left.implicitConversion >> 4;
817         // // both sides got promoted in the same way
818         // if (promotedTypeID == T_int) {
819         // // 0 >= x
820         // if ((left.constant != NotAConstant) && (left.constant.intValue() == 0)) {
821         // right.generateCode(currentScope, codeStream, valueRequired);
822         // if (valueRequired) {
823         // if (falseLabel == null) {
824         // if (trueLabel != null) {
825         // // implicitly falling through the FALSE case
826         // codeStream.ifle(trueLabel);
827         // }
828         // } else {
829         // if (trueLabel == null) {
830         // // implicitly falling through the TRUE case
831         // codeStream.ifgt(falseLabel);
832         // } else {
833         // // no implicit fall through TRUE/FALSE --> should never occur
834         // }
835         // }
836         // }
837         // // reposition the endPC
838         // codeStream.updateLastRecordedEndPC(codeStream.position);
839         // return;
840         // }
841         // // x >= 0
842         // if ((right.constant != NotAConstant) && (right.constant.intValue() == 0))
843         // {
844         // left.generateCode(currentScope, codeStream, valueRequired);
845         // if (valueRequired) {
846         // if (falseLabel == null) {
847         // if (trueLabel != null) {
848         // // implicitly falling through the FALSE case
849         // codeStream.ifge(trueLabel);
850         // }
851         // } else {
852         // if (trueLabel == null) {
853         // // implicitly falling through the TRUE case
854         // codeStream.iflt(falseLabel);
855         // } else {
856         // // no implicit fall through TRUE/FALSE --> should never occur
857         // }
858         // }
859         // }
860         // // reposition the endPC
861         // codeStream.updateLastRecordedEndPC(codeStream.position);
862         // return;
863         // }
864         // }
865         // // default comparison
866         // left.generateCode(currentScope, codeStream, valueRequired);
867         // right.generateCode(currentScope, codeStream, valueRequired);
868         // if (valueRequired) {
869         // if (falseLabel == null) {
870         // if (trueLabel != null) {
871         // // implicit falling through the FALSE case
872         // switch (promotedTypeID) {
873         // case T_int :
874         // codeStream.if_icmpge(trueLabel);
875         // break;
876         // case T_float :
877         // codeStream.fcmpl();
878         // codeStream.ifge(trueLabel);
879         // break;
880         // case T_long :
881         // codeStream.lcmp();
882         // codeStream.ifge(trueLabel);
883         // break;
884         // case T_double :
885         // codeStream.dcmpl();
886         // codeStream.ifge(trueLabel);
887         // }
888         // // reposition the endPC
889         // codeStream.updateLastRecordedEndPC(codeStream.position);
890         // return;
891         // }
892         // } else {
893         // if (trueLabel == null) {
894         // // implicit falling through the TRUE case
895         // switch (promotedTypeID) {
896         // case T_int :
897         // codeStream.if_icmplt(falseLabel);
898         // break;
899         // case T_float :
900         // codeStream.fcmpl();
901         // codeStream.iflt(falseLabel);
902         // break;
903         // case T_long :
904         // codeStream.lcmp();
905         // codeStream.iflt(falseLabel);
906         // break;
907         // case T_double :
908         // codeStream.dcmpl();
909         // codeStream.iflt(falseLabel);
910         // }
911         // // reposition the endPC
912         // codeStream.updateLastRecordedEndPC(codeStream.position);
913         // return;
914         // } else {
915         // // no implicit fall through TRUE/FALSE --> should never occur
916         // }
917         // }
918         // }
919         // }
920         //
921         // /**
922         // * Boolean generation for <
923         // */
924         // public void generateOptimizedLessThan(
925         // BlockScope currentScope,
926         // CodeStream codeStream,
927         // Label trueLabel,
928         // Label falseLabel,
929         // boolean valueRequired) {
930         //
931         // int promotedTypeID = left.implicitConversion >> 4;
932         // // both sides got promoted in the same way
933         // if (promotedTypeID == T_int) {
934         // // 0 < x
935         // if ((left.constant != NotAConstant) && (left.constant.intValue() == 0)) {
936         // right.generateCode(currentScope, codeStream, valueRequired);
937         // if (valueRequired) {
938         // if (falseLabel == null) {
939         // if (trueLabel != null) {
940         // // implicitly falling through the FALSE case
941         // codeStream.ifgt(trueLabel);
942         // }
943         // } else {
944         // if (trueLabel == null) {
945         // // implicitly falling through the TRUE case
946         // codeStream.ifle(falseLabel);
947         // } else {
948         // // no implicit fall through TRUE/FALSE --> should never occur
949         // }
950         // }
951         // }
952         // codeStream.updateLastRecordedEndPC(codeStream.position);
953         // return;
954         // }
955         // // x < 0
956         // if ((right.constant != NotAConstant) && (right.constant.intValue() == 0))
957         // {
958         // left.generateCode(currentScope, codeStream, valueRequired);
959         // if (valueRequired) {
960         // if (falseLabel == null) {
961         // if (trueLabel != null) {
962         // // implicitly falling through the FALSE case
963         // codeStream.iflt(trueLabel);
964         // }
965         // } else {
966         // if (trueLabel == null) {
967         // // implicitly falling through the TRUE case
968         // codeStream.ifge(falseLabel);
969         // } else {
970         // // no implicit fall through TRUE/FALSE --> should never occur
971         // }
972         // }
973         // }
974         // codeStream.updateLastRecordedEndPC(codeStream.position);
975         // return;
976         // }
977         // }
978         // // default comparison
979         // left.generateCode(currentScope, codeStream, valueRequired);
980         // right.generateCode(currentScope, codeStream, valueRequired);
981         // if (valueRequired) {
982         // if (falseLabel == null) {
983         // if (trueLabel != null) {
984         // // implicit falling through the FALSE case
985         // switch (promotedTypeID) {
986         // case T_int :
987         // codeStream.if_icmplt(trueLabel);
988         // break;
989         // case T_float :
990         // codeStream.fcmpg();
991         // codeStream.iflt(trueLabel);
992         // break;
993         // case T_long :
994         // codeStream.lcmp();
995         // codeStream.iflt(trueLabel);
996         // break;
997         // case T_double :
998         // codeStream.dcmpg();
999         // codeStream.iflt(trueLabel);
1000         // }
1001         // codeStream.updateLastRecordedEndPC(codeStream.position);
1002         // return;
1003         // }
1004         // } else {
1005         // if (trueLabel == null) {
1006         // // implicit falling through the TRUE case
1007         // switch (promotedTypeID) {
1008         // case T_int :
1009         // codeStream.if_icmpge(falseLabel);
1010         // break;
1011         // case T_float :
1012         // codeStream.fcmpg();
1013         // codeStream.ifge(falseLabel);
1014         // break;
1015         // case T_long :
1016         // codeStream.lcmp();
1017         // codeStream.ifge(falseLabel);
1018         // break;
1019         // case T_double :
1020         // codeStream.dcmpg();
1021         // codeStream.ifge(falseLabel);
1022         // }
1023         // codeStream.updateLastRecordedEndPC(codeStream.position);
1024         // return;
1025         // } else {
1026         // // no implicit fall through TRUE/FALSE --> should never occur
1027         // }
1028         // }
1029         // }
1030         // }
1031         //      
1032         // /**
1033         // * Boolean generation for <=
1034         // */
1035         // public void generateOptimizedLessThanOrEqual(
1036         // BlockScope currentScope,
1037         // CodeStream codeStream,
1038         // Label trueLabel,
1039         // Label falseLabel,
1040         // boolean valueRequired) {
1041         //
1042         // int promotedTypeID = left.implicitConversion >> 4;
1043         // // both sides got promoted in the same way
1044         // if (promotedTypeID == T_int) {
1045         // // 0 <= x
1046         // if ((left.constant != NotAConstant) && (left.constant.intValue() == 0)) {
1047         // right.generateCode(currentScope, codeStream, valueRequired);
1048         // if (valueRequired) {
1049         // if (falseLabel == null) {
1050         // if (trueLabel != null) {
1051         // // implicitly falling through the FALSE case
1052         // codeStream.ifge(trueLabel);
1053         // }
1054         // } else {
1055         // if (trueLabel == null) {
1056         // // implicitly falling through the TRUE case
1057         // codeStream.iflt(falseLabel);
1058         // } else {
1059         // // no implicit fall through TRUE/FALSE --> should never occur
1060         // }
1061         // }
1062         // }
1063         // // reposition the endPC
1064         // codeStream.updateLastRecordedEndPC(codeStream.position);
1065         // return;
1066         // }
1067         // // x <= 0
1068         // if ((right.constant != NotAConstant) && (right.constant.intValue() == 0))
1069         // {
1070         // left.generateCode(currentScope, codeStream, valueRequired);
1071         // if (valueRequired) {
1072         // if (falseLabel == null) {
1073         // if (trueLabel != null) {
1074         // // implicitly falling through the FALSE case
1075         // codeStream.ifle(trueLabel);
1076         // }
1077         // } else {
1078         // if (trueLabel == null) {
1079         // // implicitly falling through the TRUE case
1080         // codeStream.ifgt(falseLabel);
1081         // } else {
1082         // // no implicit fall through TRUE/FALSE --> should never occur
1083         // }
1084         // }
1085         // }
1086         // // reposition the endPC
1087         // codeStream.updateLastRecordedEndPC(codeStream.position);
1088         // return;
1089         // }
1090         // }
1091         // // default comparison
1092         // left.generateCode(currentScope, codeStream, valueRequired);
1093         // right.generateCode(currentScope, codeStream, valueRequired);
1094         // if (valueRequired) {
1095         // if (falseLabel == null) {
1096         // if (trueLabel != null) {
1097         // // implicit falling through the FALSE case
1098         // switch (promotedTypeID) {
1099         // case T_int :
1100         // codeStream.if_icmple(trueLabel);
1101         // break;
1102         // case T_float :
1103         // codeStream.fcmpg();
1104         // codeStream.ifle(trueLabel);
1105         // break;
1106         // case T_long :
1107         // codeStream.lcmp();
1108         // codeStream.ifle(trueLabel);
1109         // break;
1110         // case T_double :
1111         // codeStream.dcmpg();
1112         // codeStream.ifle(trueLabel);
1113         // }
1114         // // reposition the endPC
1115         // codeStream.updateLastRecordedEndPC(codeStream.position);
1116         // return;
1117         // }
1118         // } else {
1119         // if (trueLabel == null) {
1120         // // implicit falling through the TRUE case
1121         // switch (promotedTypeID) {
1122         // case T_int :
1123         // codeStream.if_icmpgt(falseLabel);
1124         // break;
1125         // case T_float :
1126         // codeStream.fcmpg();
1127         // codeStream.ifgt(falseLabel);
1128         // break;
1129         // case T_long :
1130         // codeStream.lcmp();
1131         // codeStream.ifgt(falseLabel);
1132         // break;
1133         // case T_double :
1134         // codeStream.dcmpg();
1135         // codeStream.ifgt(falseLabel);
1136         // }
1137         // // reposition the endPC
1138         // codeStream.updateLastRecordedEndPC(codeStream.position);
1139         // return;
1140         // } else {
1141         // // no implicit fall through TRUE/FALSE --> should never occur
1142         // }
1143         // }
1144         // }
1145         // }
1146         //      
1147         // /**
1148         // * Boolean generation for &
1149         // */
1150         // public void generateOptimizedLogicalAnd(
1151         // BlockScope currentScope,
1152         // CodeStream codeStream,
1153         // Label trueLabel,
1154         // Label falseLabel,
1155         // boolean valueRequired) {
1156         //                      
1157         // Constant condConst;
1158         // if ((left.implicitConversion & 0xF) == T_boolean) {
1159         // if ((condConst = left.optimizedBooleanConstant()) != NotAConstant) {
1160         // if (condConst.booleanValue() == true) {
1161         // // <something equivalent to true> & x
1162         // left.generateOptimizedBoolean(
1163         // currentScope,
1164         // codeStream,
1165         // trueLabel,
1166         // falseLabel,
1167         // false);
1168         // if ((bits & OnlyValueRequiredMASK) != 0) {
1169         // right.generateCode(currentScope, codeStream, valueRequired);
1170         // } else {
1171         // right.generateOptimizedBoolean(
1172         // currentScope,
1173         // codeStream,
1174         // trueLabel,
1175         // falseLabel,
1176         // valueRequired);
1177         // }
1178         // } else {
1179         // // <something equivalent to false> & x
1180         // left.generateOptimizedBoolean(
1181         // currentScope,
1182         // codeStream,
1183         // trueLabel,
1184         // falseLabel,
1185         // false);
1186         // right.generateOptimizedBoolean(
1187         // currentScope,
1188         // codeStream,
1189         // trueLabel,
1190         // falseLabel,
1191         // false);
1192         // if (valueRequired) {
1193         // if ((bits & OnlyValueRequiredMASK) != 0) {
1194         // codeStream.iconst_0();
1195         // } else {
1196         // if (falseLabel != null) {
1197         // // implicit falling through the TRUE case
1198         // codeStream.goto_(falseLabel);
1199         // }
1200         // }
1201         // }
1202         // // reposition the endPC
1203         // codeStream.updateLastRecordedEndPC(codeStream.position);
1204         // }
1205         // return;
1206         // }
1207         // if ((condConst = right.optimizedBooleanConstant()) != NotAConstant) {
1208         // if (condConst.booleanValue() == true) {
1209         // // x & <something equivalent to true>
1210         // if ((bits & OnlyValueRequiredMASK) != 0) {
1211         // left.generateCode(currentScope, codeStream, valueRequired);
1212         // } else {
1213         // left.generateOptimizedBoolean(
1214         // currentScope,
1215         // codeStream,
1216         // trueLabel,
1217         // falseLabel,
1218         // valueRequired);
1219         // }
1220         // right.generateOptimizedBoolean(
1221         // currentScope,
1222         // codeStream,
1223         // trueLabel,
1224         // falseLabel,
1225         // false);
1226         // } else {
1227         // // x & <something equivalent to false>
1228         // left.generateOptimizedBoolean(
1229         // currentScope,
1230         // codeStream,
1231         // trueLabel,
1232         // falseLabel,
1233         // false);
1234         // right.generateOptimizedBoolean(
1235         // currentScope,
1236         // codeStream,
1237         // trueLabel,
1238         // falseLabel,
1239         // false);
1240         // if (valueRequired) {
1241         // if ((bits & OnlyValueRequiredMASK) != 0) {
1242         // codeStream.iconst_0();
1243         // } else {
1244         // if (falseLabel != null) {
1245         // // implicit falling through the TRUE case
1246         // codeStream.goto_(falseLabel);
1247         // }
1248         // }
1249         // }
1250         // // reposition the endPC
1251         // codeStream.updateLastRecordedEndPC(codeStream.position);
1252         // }
1253         // return;
1254         // }
1255         // }
1256         // // default case
1257         // left.generateCode(currentScope, codeStream, valueRequired);
1258         // right.generateCode(currentScope, codeStream, valueRequired);
1259         // if (valueRequired) {
1260         // codeStream.iand();
1261         // if ((bits & OnlyValueRequiredMASK) == 0) {
1262         // if (falseLabel == null) {
1263         // if (trueLabel != null) {
1264         // // implicit falling through the FALSE case
1265         // codeStream.ifne(trueLabel);
1266         // }
1267         // } else {
1268         // // implicit falling through the TRUE case
1269         // if (trueLabel == null) {
1270         // codeStream.ifeq(falseLabel);
1271         // } else {
1272         // // no implicit fall through TRUE/FALSE --> should never occur
1273         // }
1274         // }
1275         // }
1276         // }
1277         // // reposition the endPC
1278         // codeStream.updateLastRecordedEndPC(codeStream.position);
1279         // }
1280         //      
1281         // /**
1282         // * Boolean generation for |
1283         // */
1284         // public void generateOptimizedLogicalOr(
1285         // BlockScope currentScope,
1286         // CodeStream codeStream,
1287         // Label trueLabel,
1288         // Label falseLabel,
1289         // boolean valueRequired) {
1290         //                      
1291         // Constant condConst;
1292         // if ((left.implicitConversion & 0xF) == T_boolean) {
1293         // if ((condConst = left.optimizedBooleanConstant()) != NotAConstant) {
1294         // if (condConst.booleanValue() == true) {
1295         // // <something equivalent to true> | x
1296         // left.generateOptimizedBoolean(
1297         // currentScope,
1298         // codeStream,
1299         // trueLabel,
1300         // falseLabel,
1301         // false);
1302         // right.generateOptimizedBoolean(
1303         // currentScope,
1304         // codeStream,
1305         // trueLabel,
1306         // falseLabel,
1307         // false);
1308         // if (valueRequired) {
1309         // if ((bits & OnlyValueRequiredMASK) != 0) {
1310         // codeStream.iconst_1();
1311         // } else {
1312         // if (trueLabel != null) {
1313         // codeStream.goto_(trueLabel);
1314         // }
1315         // }
1316         // }
1317         // // reposition the endPC
1318         // codeStream.updateLastRecordedEndPC(codeStream.position);
1319         // } else {
1320         // // <something equivalent to false> | x
1321         // left.generateOptimizedBoolean(
1322         // currentScope,
1323         // codeStream,
1324         // trueLabel,
1325         // falseLabel,
1326         // false);
1327         // if ((bits & OnlyValueRequiredMASK) != 0) {
1328         // right.generateCode(currentScope, codeStream, valueRequired);
1329         // } else {
1330         // right.generateOptimizedBoolean(
1331         // currentScope,
1332         // codeStream,
1333         // trueLabel,
1334         // falseLabel,
1335         // valueRequired);
1336         // }
1337         // }
1338         // return;
1339         // }
1340         // if ((condConst = right.optimizedBooleanConstant()) != NotAConstant) {
1341         // if (condConst.booleanValue() == true) {
1342         // // x | <something equivalent to true>
1343         // left.generateOptimizedBoolean(
1344         // currentScope,
1345         // codeStream,
1346         // trueLabel,
1347         // falseLabel,
1348         // false);
1349         // right.generateOptimizedBoolean(
1350         // currentScope,
1351         // codeStream,
1352         // trueLabel,
1353         // falseLabel,
1354         // false);
1355         // if (valueRequired) {
1356         // if ((bits & OnlyValueRequiredMASK) != 0) {
1357         // codeStream.iconst_1();
1358         // } else {
1359         // if (trueLabel != null) {
1360         // codeStream.goto_(trueLabel);
1361         // }
1362         // }
1363         // }
1364         // // reposition the endPC
1365         // codeStream.updateLastRecordedEndPC(codeStream.position);
1366         // } else {
1367         // // x | <something equivalent to false>
1368         // if ((bits & OnlyValueRequiredMASK) != 0) {
1369         // left.generateCode(currentScope, codeStream, valueRequired);
1370         // } else {
1371         // left.generateOptimizedBoolean(
1372         // currentScope,
1373         // codeStream,
1374         // trueLabel,
1375         // falseLabel,
1376         // valueRequired);
1377         // }
1378         // right.generateOptimizedBoolean(
1379         // currentScope,
1380         // codeStream,
1381         // trueLabel,
1382         // falseLabel,
1383         // false);
1384         // }
1385         // return;
1386         // }
1387         // }
1388         // // default case
1389         // left.generateCode(currentScope, codeStream, valueRequired);
1390         // right.generateCode(currentScope, codeStream, valueRequired);
1391         // if (valueRequired) {
1392         // codeStream.ior();
1393         // if ((bits & OnlyValueRequiredMASK) == 0) {
1394         // if (falseLabel == null) {
1395         // if (trueLabel != null) {
1396         // // implicit falling through the FALSE case
1397         // codeStream.ifne(trueLabel);
1398         // }
1399         // } else {
1400         // // implicit falling through the TRUE case
1401         // if (trueLabel == null) {
1402         // codeStream.ifeq(falseLabel);
1403         // } else {
1404         // // no implicit fall through TRUE/FALSE --> should never occur
1405         // }
1406         // }
1407         // }
1408         // }
1409         // // reposition the endPC
1410         // codeStream.updateLastRecordedEndPC(codeStream.position);
1411         // }
1412         //      
1413         // /**
1414         // * Boolean generation for ^
1415         // */
1416         // public void generateOptimizedLogicalXor(
1417         // BlockScope currentScope,
1418         // CodeStream codeStream,
1419         // Label trueLabel,
1420         // Label falseLabel,
1421         // boolean valueRequired) {
1422         //                      
1423         // Constant condConst;
1424         // if ((left.implicitConversion & 0xF) == T_boolean) {
1425         // if ((condConst = left.optimizedBooleanConstant()) != NotAConstant) {
1426         // if (condConst.booleanValue() == true) {
1427         // // <something equivalent to true> ^ x
1428         // left.generateOptimizedBoolean(
1429         // currentScope,
1430         // codeStream,
1431         // trueLabel,
1432         // falseLabel,
1433         // false);
1434         // right.generateOptimizedBoolean(
1435         // currentScope,
1436         // codeStream,
1437         // falseLabel,
1438         // trueLabel,
1439         // valueRequired);
1440         // } else {
1441         // // <something equivalent to false> ^ x
1442         // left.generateOptimizedBoolean(
1443         // currentScope,
1444         // codeStream,
1445         // trueLabel,
1446         // falseLabel,
1447         // false);
1448         // if ((bits & OnlyValueRequiredMASK) != 0) {
1449         // right.generateCode(currentScope, codeStream, valueRequired);
1450         // } else {
1451         // right.generateOptimizedBoolean(
1452         // currentScope,
1453         // codeStream,
1454         // trueLabel,
1455         // falseLabel,
1456         // valueRequired);
1457         // }
1458         // }
1459         // return;
1460         // }
1461         // if ((condConst = right.optimizedBooleanConstant()) != NotAConstant) {
1462         // if (condConst.booleanValue() == true) {
1463         // // x ^ <something equivalent to true>
1464         // left.generateOptimizedBoolean(
1465         // currentScope,
1466         // codeStream,
1467         // falseLabel,
1468         // trueLabel,
1469         // valueRequired);
1470         // right.generateOptimizedBoolean(
1471         // currentScope,
1472         // codeStream,
1473         // trueLabel,
1474         // falseLabel,
1475         // false);
1476         // } else {
1477         // // x ^ <something equivalent to false>
1478         // if ((bits & OnlyValueRequiredMASK) != 0) {
1479         // left.generateCode(currentScope, codeStream, valueRequired);
1480         // } else {
1481         // left.generateOptimizedBoolean(
1482         // currentScope,
1483         // codeStream,
1484         // trueLabel,
1485         // falseLabel,
1486         // valueRequired);
1487         // }
1488         // right.generateOptimizedBoolean(
1489         // currentScope,
1490         // codeStream,
1491         // trueLabel,
1492         // falseLabel,
1493         // false);
1494         // }
1495         // return;
1496         // }
1497         // }
1498         // // default case
1499         // left.generateCode(currentScope, codeStream, valueRequired);
1500         // right.generateCode(currentScope, codeStream, valueRequired);
1501         // if (valueRequired) {
1502         // codeStream.ixor();
1503         // if ((bits & OnlyValueRequiredMASK) == 0) {
1504         // if (falseLabel == null) {
1505         // if (trueLabel != null) {
1506         // // implicit falling through the FALSE case
1507         // codeStream.ifne(trueLabel);
1508         // }
1509         // } else {
1510         // // implicit falling through the TRUE case
1511         // if (trueLabel == null) {
1512         // codeStream.ifeq(falseLabel);
1513         // } else {
1514         // // no implicit fall through TRUE/FALSE --> should never occur
1515         // }
1516         // }
1517         // }
1518         // }
1519         // // reposition the endPC
1520         // codeStream.updateLastRecordedEndPC(codeStream.position);
1521         // }
1522         //      
1523         // public void generateOptimizedStringBuffer(
1524         // BlockScope blockScope,
1525         // CodeStream codeStream,
1526         // int typeID) {
1527         //                      
1528         // /* In the case trying to make a string concatenation, there is no need to
1529         // create a new
1530         // * string buffer, thus use a lower-level API for code generation involving
1531         // only the
1532         // * appending of arguments to the existing StringBuffer
1533         // */
1534         //
1535         // if ((((bits & OperatorMASK) >> OperatorSHIFT) == PLUS)
1536         // && ((bits & ReturnTypeIDMASK) == T_String)) {
1537         // if (constant != NotAConstant) {
1538         // codeStream.generateConstant(constant, implicitConversion);
1539         // codeStream.invokeStringBufferAppendForType(implicitConversion & 0xF);
1540         // } else {
1541         // int pc = codeStream.position;
1542         // left.generateOptimizedStringBuffer(
1543         // blockScope,
1544         // codeStream,
1545         // left.implicitConversion & 0xF);
1546         // codeStream.recordPositionsFrom(pc, left.sourceStart);
1547         // pc = codeStream.position;
1548         // right.generateOptimizedStringBuffer(
1549         // blockScope,
1550         // codeStream,
1551         // right.implicitConversion & 0xF);
1552         // codeStream.recordPositionsFrom(pc, right.sourceStart);
1553         // }
1554         // } else {
1555         // super.generateOptimizedStringBuffer(blockScope, codeStream, typeID);
1556         // }
1557         // }
1558         //      
1559         // public void generateOptimizedStringBufferCreation(
1560         // BlockScope blockScope,
1561         // CodeStream codeStream,
1562         // int typeID) {
1563         //                      
1564         // /* In the case trying to make a string concatenation, there is no need to
1565         // create a new
1566         // * string buffer, thus use a lower-level API for code generation involving
1567         // only the
1568         // * appending of arguments to the existing StringBuffer
1569         // */
1570         //
1571         // if ((((bits & OperatorMASK) >> OperatorSHIFT) == PLUS)
1572         // && ((bits & ReturnTypeIDMASK) == T_String)) {
1573         // if (constant != NotAConstant) {
1574         // codeStream.newStringBuffer(); // new: java.lang.StringBuffer
1575         // codeStream.dup();
1576         // codeStream.ldc(constant.stringValue());
1577         // codeStream.invokeStringBufferStringConstructor();
1578         // // invokespecial: java.lang.StringBuffer.<init>(Ljava.lang.String;)V
1579         // } else {
1580         // int pc = codeStream.position;
1581         // left.generateOptimizedStringBufferCreation(
1582         // blockScope,
1583         // codeStream,
1584         // left.implicitConversion & 0xF);
1585         // codeStream.recordPositionsFrom(pc, left.sourceStart);
1586         // pc = codeStream.position;
1587         // right.generateOptimizedStringBuffer(
1588         // blockScope,
1589         // codeStream,
1590         // right.implicitConversion & 0xF);
1591         // codeStream.recordPositionsFrom(pc, right.sourceStart);
1592         // }
1593         // } else {
1594         // super.generateOptimizedStringBufferCreation(blockScope, codeStream,
1595         // typeID);
1596         // }
1597         // }
1598         //      
1599         // public boolean isCompactableOperation() {
1600         //              
1601         // return true;
1602         // }
1603         //      
1604         // public void optimizedBooleanConstant(int leftId, int operator, int
1605         // rightId) {
1606         //
1607         // switch (operator) {
1608         // case AND :
1609         // if ((leftId != T_boolean) || (rightId != T_boolean))
1610         // return;
1611         // case AND_AND :
1612         // Constant cst;
1613         // if ((cst = left.optimizedBooleanConstant()) != NotAConstant) {
1614         // if (cst.booleanValue() == false) { // left is equivalent to false
1615         // optimizedBooleanConstant = cst; // constant(false)
1616         // return;
1617         // } else { //left is equivalent to true
1618         // if ((cst = right.optimizedBooleanConstant()) != NotAConstant) {
1619         // optimizedBooleanConstant = cst;
1620         // // the conditional result is equivalent to the right conditional value
1621         // }
1622         // return;
1623         // }
1624         // }
1625         // if ((cst = right.optimizedBooleanConstant()) != NotAConstant) {
1626         // if (cst.booleanValue() == false) { // right is equivalent to false
1627         // optimizedBooleanConstant = cst; // constant(false)
1628         // }
1629         // }
1630         // return;
1631         // case OR :
1632         // if ((leftId != T_boolean) || (rightId != T_boolean))
1633         // return;
1634         // case OR_OR :
1635         // if ((cst = left.optimizedBooleanConstant()) != NotAConstant) {
1636         // if (cst.booleanValue() == true) { // left is equivalent to true
1637         // optimizedBooleanConstant = cst; // constant(true)
1638         // return;
1639         // } else { //left is equivalent to false
1640         // if ((cst = right.optimizedBooleanConstant()) != NotAConstant) {
1641         // optimizedBooleanConstant = cst;
1642         // }
1643         // return;
1644         // }
1645         // }
1646         // if ((cst = right.optimizedBooleanConstant()) != NotAConstant) {
1647         // if (cst.booleanValue() == true) { // right is equivalent to true
1648         // optimizedBooleanConstant = cst; // constant(true)
1649         // }
1650         // }
1651         // }
1652         // }
1653         public StringBuffer printExpressionNoParenthesis(int indent,
1654                         StringBuffer output) {
1655
1656                 left.printExpression(indent, output).append(' ').append(
1657                                 operatorToString()).append(' ');
1658                 return right.printExpression(0, output);
1659         }
1660
1661         public TypeBinding resolveType(BlockScope scope) {
1662
1663                 // use the id of the type to navigate into the table
1664                 TypeBinding leftTb = left.resolveType(scope);
1665                 TypeBinding rightTb = right.resolveType(scope);
1666                 if (leftTb == null || rightTb == null) {
1667                         constant = Constant.NotAConstant;
1668                         return null;
1669                 }
1670                 int leftId = leftTb.id;
1671                 int rightId = rightTb.id;
1672                 if (leftId > 15 || rightId > 15) { // must convert String + Object ||
1673                                                                                         // Object + String
1674                         if (leftId == T_String) {
1675                                 rightId = T_Object;
1676                         } else if (rightId == T_String) {
1677                                 leftId = T_Object;
1678                         } else {
1679                                 constant = Constant.NotAConstant;
1680                                 scope.problemReporter().invalidOperator(this, leftTb, rightTb);
1681                                 return null;
1682                         }
1683                 }
1684                 if (((bits & OperatorMASK) >> OperatorSHIFT) == PLUS) {
1685                         if (leftId == T_String
1686                                         && rightTb.isArrayType()
1687                                         && ((ArrayBinding) rightTb).elementsType(scope) == CharBinding)
1688                                 scope
1689                                                 .problemReporter()
1690                                                 .signalNoImplicitStringConversionForCharArrayExpression(
1691                                                                 right);
1692                         else if (rightId == T_String
1693                                         && leftTb.isArrayType()
1694                                         && ((ArrayBinding) leftTb).elementsType(scope) == CharBinding)
1695                                 scope
1696                                                 .problemReporter()
1697                                                 .signalNoImplicitStringConversionForCharArrayExpression(
1698                                                                 left);
1699                 }
1700
1701                 // the code is an int
1702                 // (cast) left Op (cast) rigth --> result
1703                 // 0000 0000 0000 0000 0000
1704                 // <<16 <<12 <<8 <<4 <<0
1705
1706                 // Don't test for result = 0. If it is zero, some more work is done.
1707                 // On the one hand when it is not zero (correct code) we avoid doing the
1708                 // test
1709                 int result = ResolveTypeTables[(bits & OperatorMASK) >> OperatorSHIFT][(leftId << 4)
1710                                 + rightId];
1711                 left.implicitConversion = result >>> 12;
1712                 right.implicitConversion = (result >>> 4) & 0x000FF;
1713
1714                 bits |= result & 0xF;
1715                 switch (result & 0xF) { // record the current ReturnTypeID
1716                 // only switch on possible result type.....
1717                 case T_boolean:
1718                         this.resolvedType = BooleanBinding;
1719                         break;
1720                 case T_byte:
1721                         this.resolvedType = ByteBinding;
1722                         break;
1723                 case T_char:
1724                         this.resolvedType = CharBinding;
1725                         break;
1726                 case T_double:
1727                         this.resolvedType = DoubleBinding;
1728                         break;
1729                 case T_float:
1730                         this.resolvedType = FloatBinding;
1731                         break;
1732                 case T_int:
1733                         this.resolvedType = IntBinding;
1734                         break;
1735                 case T_long:
1736                         this.resolvedType = LongBinding;
1737                         break;
1738                 case T_String:
1739                         this.resolvedType = scope.getJavaLangString();
1740                         break;
1741                 default: // error........
1742                         constant = Constant.NotAConstant;
1743                         scope.problemReporter().invalidOperator(this, leftTb, rightTb);
1744                         return null;
1745                 }
1746
1747                 // compute the constant when valid
1748                 computeConstant(scope, leftId, rightId);
1749                 return this.resolvedType;
1750         }
1751
1752         public String toStringExpressionNoParenthesis() {
1753
1754                 return left.toStringExpression() + " " + //$NON-NLS-1$
1755                                 operatorToString() + " " + //$NON-NLS-1$
1756                                 right.toStringExpression();
1757         }
1758
1759         public void traverse(ASTVisitor visitor, BlockScope scope) {
1760
1761                 if (visitor.visit(this, scope)) {
1762                         left.traverse(visitor, scope);
1763                         right.traverse(visitor, scope);
1764                 }
1765                 visitor.endVisit(this, scope);
1766         }
1767 }