net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/ast/BinaryExpression.java

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