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