net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/codegen/CodeStream.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.codegen;
  12
  13 import net.sourceforge.phpdt.internal.compiler.*;
  14
  15 import net.sourceforge.phpdt.internal.compiler.impl.*;
  16 import net.sourceforge.phpdt.internal.compiler.ast.*;
  17 import net.sourceforge.phpdt.internal.compiler.classfmt.*;
  18 import net.sourceforge.phpdt.internal.compiler.flow.*;
  19 import net.sourceforge.phpdt.internal.compiler.lookup.*;
  20
  21 public class CodeStream implements OperatorIds, ClassFileConstants, Opcodes, BaseTypes, TypeConstants, TypeIds {
  22   // It will be responsible for the following items.
  23
  24   // -> Tracking Max Stack.
  25
  26   public int stackMax; // Use Ints to keep from using extra bc when adding
  27   public int stackDepth; // Use Ints to keep from using extra bc when adding
  28   public int maxLocals;
  29   public static final int max = 100; // Maximum size of the code array
  30   public static final int growFactor = 400;
  31   public static final int LABELS_INCREMENT = 5;
  32   public byte[] bCodeStream;
  33   public int pcToSourceMapSize;
  34   public int[] pcToSourceMap = new int[24];
  35   public int lastEntryPC; // last entry recorded
  36   public int[] lineSeparatorPositions;
  37   public int position; // So when first set can be incremented
  38   public int classFileOffset;
  39   public int startingClassFileOffset; // I need to keep the starting point inside the byte array
  40   public ConstantPool constantPool;
  41   // The constant pool used to generate bytecodes that need to store information into the constant pool
  42   public ClassFile classFile; // The current classfile it is associated to.
  43   // local variable attributes output
  44   public static final int LOCALS_INCREMENT = 10;
  45   public LocalVariableBinding[] locals = new LocalVariableBinding[LOCALS_INCREMENT];
  46   static LocalVariableBinding[] noLocals = new LocalVariableBinding[LOCALS_INCREMENT];
  47   public LocalVariableBinding[] visibleLocals = new LocalVariableBinding[LOCALS_INCREMENT];
  48   static LocalVariableBinding[] noVisibleLocals = new LocalVariableBinding[LOCALS_INCREMENT];
  49   int visibleLocalsCount;
  50   public AbstractMethodDeclaration methodDeclaration;
  51   public ExceptionLabel[] exceptionHandlers = new ExceptionLabel[LABELS_INCREMENT];
  52   static ExceptionLabel[] noExceptionHandlers = new ExceptionLabel[LABELS_INCREMENT];
  53   public int exceptionHandlersNumber;
  54   public static FieldBinding[] ImplicitThis = new FieldBinding[] {
  55   };
  56   public boolean generateLineNumberAttributes;
  57   public boolean generateLocalVariableTableAttributes;
  58   public boolean preserveUnusedLocals;
  59   // store all the labels placed at the current position to be able to optimize
  60   // a jump to the next bytecode.
  61   public Label[] labels = new Label[LABELS_INCREMENT];
  62   static Label[] noLabels = new Label[LABELS_INCREMENT];
  63   public int countLabels;
  64   public int allLocalsCounter;
  65   public int maxFieldCount;
  66   // to handle goto_w
  67   public boolean wideMode = false;
  68   public static final CompilationResult RESTART_IN_WIDE_MODE = new CompilationResult((char[]) null, 0, 0, 0);
  69
  70   public CodeStream(ClassFile classFile) {
  71     generateLineNumberAttributes = (classFile.produceDebugAttributes & CompilerOptions.Lines) != 0;
  72     generateLocalVariableTableAttributes = (classFile.produceDebugAttributes & CompilerOptions.Vars) != 0;
  73     if (generateLineNumberAttributes) {
  74       lineSeparatorPositions = classFile.referenceBinding.scope.referenceCompilationUnit().compilationResult.lineSeparatorPositions;
  75     }
  76   }
  77   final public void aaload() {
  78     countLabels = 0;
  79     stackDepth--;
  80     try {
  81       position++;
  82       bCodeStream[classFileOffset++] = OPC_aaload;
  83     } catch (IndexOutOfBoundsException e) {
  84       resizeByteArray(OPC_aaload);
  85     }
  86   }
  87   final public void aastore() {
  88     countLabels = 0;
  89     stackDepth -= 3;
  90     try {
  91       position++;
  92       bCodeStream[classFileOffset++] = OPC_aastore;
  93     } catch (IndexOutOfBoundsException e) {
  94       resizeByteArray(OPC_aastore);
  95     }
  96   }
  97   final public void aconst_null() {
  98     countLabels = 0;
  99     stackDepth++;
 100     if (stackDepth > stackMax)
 101       stackMax = stackDepth;
 102     try {
 103       position++;
 104       bCodeStream[classFileOffset++] = OPC_aconst_null;
 105     } catch (IndexOutOfBoundsException e) {
 106       resizeByteArray(OPC_aconst_null);
 107     }
 108   }
 109   public final void addDefinitelyAssignedVariables(Scope scope, int initStateIndex) {
 110     // Required to fix 1PR0XVS: LFRE:WINNT - Compiler: variable table for method appears incorrect
 111     if (!generateLocalVariableTableAttributes)
 112       return;
 113     /*  if (initStateIndex == lastInitStateIndexWhenAddingInits)
 114                 return;
 115         lastInitStateIndexWhenAddingInits = initStateIndex;
 116         if (lastInitStateIndexWhenRemovingInits != initStateIndex){
 117                 lastInitStateIndexWhenRemovingInits = -2; // reinitialize remove index
 118                 // remove(1)-add(1)-remove(1) -> ignore second remove
 119                 // remove(1)-add(2)-remove(1) -> perform second remove
 120         }
 121
 122     */
 123     for (int i = 0; i < visibleLocalsCount; i++) {
 124       LocalVariableBinding localBinding = visibleLocals[i];
 125       if (localBinding != null) {
 126         // Check if the local is definitely assigned
 127         if ((initStateIndex != -1) && isDefinitelyAssigned(scope, initStateIndex, localBinding)) {
 128           if ((localBinding.initializationCount == 0)
 129             || (localBinding.initializationPCs[((localBinding.initializationCount - 1) << 1) + 1] != -1)) {
 130             /* There are two cases:
 131              * 1) there is no initialization interval opened ==> add an opened interval
 132              * 2) there is already some initialization intervals but the last one is closed ==> add an opened interval
 133              * An opened interval means that the value at localBinding.initializationPCs[localBinding.initializationCount - 1][1]
 134              * is equals to -1.
 135              * initializationPCs is a collection of pairs of int:
 136              *  first value is the startPC and second value is the endPC. -1 one for the last value means that the interval
 137              *  is not closed yet.
 138              */
 139             localBinding.recordInitializationStartPC(position);
 140           }
 141         }
 142       }
 143     }
 144   }
 145   public void addLabel(Label aLabel) {
 146     if (countLabels == labels.length)
 147       System.arraycopy(labels, 0, (labels = new Label[countLabels + LABELS_INCREMENT]), 0, countLabels);
 148     labels[countLabels++] = aLabel;
 149   }
 150   public void addVisibleLocalVariable(LocalVariableBinding localBinding) {
 151     if (!generateLocalVariableTableAttributes)
 152       return;
 153
 154     if (visibleLocalsCount >= visibleLocals.length) {
 155       System.arraycopy(visibleLocals, 0, (visibleLocals = new LocalVariableBinding[visibleLocalsCount * 2]), 0, visibleLocalsCount);
 156     }
 157     visibleLocals[visibleLocalsCount++] = localBinding;
 158   }
 159   final public void aload(int iArg) {
 160     countLabels = 0;
 161     stackDepth++;
 162     if (stackDepth > stackMax)
 163       stackMax = stackDepth;
 164     if (maxLocals <= iArg) {
 165       maxLocals = iArg + 1;
 166     }
 167     if (iArg > 255) { // Widen
 168       try {
 169         position++;
 170         bCodeStream[classFileOffset++] = OPC_wide;
 171       } catch (IndexOutOfBoundsException e) {
 172         resizeByteArray(OPC_wide);
 173       }
 174       try {
 175         position++;
 176         bCodeStream[classFileOffset++] = OPC_aload;
 177       } catch (IndexOutOfBoundsException e) {
 178         resizeByteArray(OPC_aload);
 179       }
 180       writeUnsignedShort(iArg);
 181     } else {
 182       // Don't need to use the wide bytecode
 183       try {
 184         position++;
 185         bCodeStream[classFileOffset++] = OPC_aload;
 186       } catch (IndexOutOfBoundsException e) {
 187         resizeByteArray(OPC_aload);
 188       }
 189       try {
 190         position++;
 191         bCodeStream[classFileOffset++] = (byte) (iArg);
 192       } catch (IndexOutOfBoundsException e) {
 193         resizeByteArray((byte) iArg);
 194       }
 195     }
 196   }
 197   final public void aload_0() {
 198     countLabels = 0;
 199     stackDepth++;
 200     if (stackDepth > stackMax)
 201       stackMax = stackDepth;
 202     if (maxLocals == 0) {
 203       maxLocals = 1;
 204     }
 205     try {
 206       position++;
 207       bCodeStream[classFileOffset++] = OPC_aload_0;
 208     } catch (IndexOutOfBoundsException e) {
 209       resizeByteArray(OPC_aload_0);
 210     }
 211   }
 212   final public void aload_1() {
 213     countLabels = 0;
 214     stackDepth++;
 215     if (stackDepth > stackMax)
 216       stackMax = stackDepth;
 217     if (maxLocals <= 1) {
 218       maxLocals = 2;
 219     }
 220     try {
 221       position++;
 222       bCodeStream[classFileOffset++] = OPC_aload_1;
 223     } catch (IndexOutOfBoundsException e) {
 224       resizeByteArray(OPC_aload_1);
 225     }
 226   }
 227   final public void aload_2() {
 228     countLabels = 0;
 229     stackDepth++;
 230     if (stackDepth > stackMax)
 231       stackMax = stackDepth;
 232     if (maxLocals <= 2) {
 233       maxLocals = 3;
 234     }
 235     try {
 236       position++;
 237       bCodeStream[classFileOffset++] = OPC_aload_2;
 238     } catch (IndexOutOfBoundsException e) {
 239       resizeByteArray(OPC_aload_2);
 240     }
 241   }
 242   final public void aload_3() {
 243     countLabels = 0;
 244     stackDepth++;
 245     if (stackDepth > stackMax)
 246       stackMax = stackDepth;
 247     if (maxLocals <= 3) {
 248       maxLocals = 4;
 249     }
 250     try {
 251       position++;
 252       bCodeStream[classFileOffset++] = OPC_aload_3;
 253     } catch (IndexOutOfBoundsException e) {
 254       resizeByteArray(OPC_aload_3);
 255     }
 256   }
 257   public final void anewarray(TypeBinding typeBinding) {
 258     countLabels = 0;
 259     try {
 260       position++;
 261       bCodeStream[classFileOffset++] = OPC_anewarray;
 262     } catch (IndexOutOfBoundsException e) {
 263       resizeByteArray(OPC_anewarray);
 264     }
 265     writeUnsignedShort(constantPool.literalIndex(typeBinding));
 266   }
 267   public void anewarrayJavaLangClass() {
 268     // anewarray: java.lang.Class
 269     countLabels = 0;
 270     try {
 271       position++;
 272       bCodeStream[classFileOffset++] = OPC_anewarray;
 273     } catch (IndexOutOfBoundsException e) {
 274       resizeByteArray(OPC_anewarray);
 275     }
 276     writeUnsignedShort(constantPool.literalIndexForJavaLangClass());
 277   }
 278   public void anewarrayJavaLangObject() {
 279     // anewarray: java.lang.Object
 280     countLabels = 0;
 281     try {
 282       position++;
 283       bCodeStream[classFileOffset++] = OPC_anewarray;
 284     } catch (IndexOutOfBoundsException e) {
 285       resizeByteArray(OPC_anewarray);
 286     }
 287     writeUnsignedShort(constantPool.literalIndexForJavaLangObject());
 288   }
 289   final public void areturn() {
 290     countLabels = 0;
 291     stackDepth--;
 292     // the stackDepth should be equal to 0
 293     try {
 294       position++;
 295       bCodeStream[classFileOffset++] = OPC_areturn;
 296     } catch (IndexOutOfBoundsException e) {
 297       resizeByteArray(OPC_areturn);
 298     }
 299   }
 300   public void arrayAt(int typeBindingID) {
 301     switch (typeBindingID) {
 302       case T_int :
 303         this.iaload();
 304         break;
 305       case T_byte :
 306       case T_boolean :
 307         this.baload();
 308         break;
 309       case T_short :
 310         this.saload();
 311         break;
 312       case T_char :
 313         this.caload();
 314         break;
 315       case T_long :
 316         this.laload();
 317         break;
 318       case T_float :
 319         this.faload();
 320         break;
 321       case T_double :
 322         this.daload();
 323         break;
 324       default :
 325         this.aaload();
 326     }
 327   }
 328   public void arrayAtPut(int elementTypeID, boolean valueRequired) {
 329     switch (elementTypeID) {
 330       case T_int :
 331         if (valueRequired)
 332           dup_x2();
 333         iastore();
 334         break;
 335       case T_byte :
 336       case T_boolean :
 337         if (valueRequired)
 338           dup_x2();
 339         bastore();
 340         break;
 341       case T_short :
 342         if (valueRequired)
 343           dup_x2();
 344         sastore();
 345         break;
 346       case T_char :
 347         if (valueRequired)
 348           dup_x2();
 349         castore();
 350         break;
 351       case T_long :
 352         if (valueRequired)
 353           dup2_x2();
 354         lastore();
 355         break;
 356       case T_float :
 357         if (valueRequired)
 358           dup_x2();
 359         fastore();
 360         break;
 361       case T_double :
 362         if (valueRequired)
 363           dup2_x2();
 364         dastore();
 365         break;
 366       default :
 367         if (valueRequired)
 368           dup_x2();
 369         aastore();
 370     }
 371   }
 372   final public void arraylength() {
 373     countLabels = 0;
 374     try {
 375       position++;
 376       bCodeStream[classFileOffset++] = OPC_arraylength;
 377     } catch (IndexOutOfBoundsException e) {
 378       resizeByteArray(OPC_arraylength);
 379     }
 380   }
 381   final public void astore(int iArg) {
 382     countLabels = 0;
 383     stackDepth--;
 384     if (maxLocals <= iArg) {
 385       maxLocals = iArg + 1;
 386     }
 387     if (iArg > 255) { // Widen
 388       try {
 389         position++;
 390         bCodeStream[classFileOffset++] = OPC_wide;
 391       } catch (IndexOutOfBoundsException e) {
 392         resizeByteArray(OPC_wide);
 393       }
 394       try {
 395         position++;
 396         bCodeStream[classFileOffset++] = OPC_astore;
 397       } catch (IndexOutOfBoundsException e) {
 398         resizeByteArray(OPC_astore);
 399       }
 400       writeUnsignedShort(iArg);
 401     } else {
 402       try {
 403         position++;
 404         bCodeStream[classFileOffset++] = OPC_astore;
 405       } catch (IndexOutOfBoundsException e) {
 406         resizeByteArray(OPC_astore);
 407       }
 408       try {
 409         position++;
 410         bCodeStream[classFileOffset++] = (byte) iArg;
 411       } catch (IndexOutOfBoundsException e) {
 412         resizeByteArray((byte) iArg);
 413       }
 414     }
 415   }
 416   final public void astore_0() {
 417     countLabels = 0;
 418     stackDepth--;
 419     if (maxLocals == 0) {
 420       maxLocals = 1;
 421     }
 422     try {
 423       position++;
 424       bCodeStream[classFileOffset++] = OPC_astore_0;
 425     } catch (IndexOutOfBoundsException e) {
 426       resizeByteArray(OPC_astore_0);
 427     }
 428   }
 429   final public void astore_1() {
 430     countLabels = 0;
 431     stackDepth--;
 432     if (maxLocals <= 1) {
 433       maxLocals = 2;
 434     }
 435     try {
 436       position++;
 437       bCodeStream[classFileOffset++] = OPC_astore_1;
 438     } catch (IndexOutOfBoundsException e) {
 439       resizeByteArray(OPC_astore_1);
 440     }
 441   }
 442   final public void astore_2() {
 443     countLabels = 0;
 444     stackDepth--;
 445     if (maxLocals <= 2) {
 446       maxLocals = 3;
 447     }
 448     try {
 449       position++;
 450       bCodeStream[classFileOffset++] = OPC_astore_2;
 451     } catch (IndexOutOfBoundsException e) {
 452       resizeByteArray(OPC_astore_2);
 453     }
 454   }
 455   final public void astore_3() {
 456     countLabels = 0;
 457     stackDepth--;
 458     if (maxLocals <= 3) {
 459       maxLocals = 4;
 460     }
 461     try {
 462       position++;
 463       bCodeStream[classFileOffset++] = OPC_astore_3;
 464     } catch (IndexOutOfBoundsException e) {
 465       resizeByteArray(OPC_astore_3);
 466     }
 467   }
 468   final public void athrow() {
 469     countLabels = 0;
 470     stackDepth--;
 471     try {
 472       position++;
 473       bCodeStream[classFileOffset++] = OPC_athrow;
 474     } catch (IndexOutOfBoundsException e) {
 475       resizeByteArray(OPC_athrow);
 476     }
 477   }
 478   final public void baload() {
 479     countLabels = 0;
 480     stackDepth--;
 481     try {
 482       position++;
 483       bCodeStream[classFileOffset++] = OPC_baload;
 484     } catch (IndexOutOfBoundsException e) {
 485       resizeByteArray(OPC_baload);
 486     }
 487   }
 488   final public void bastore() {
 489     countLabels = 0;
 490     stackDepth -= 3;
 491     try {
 492       position++;
 493       bCodeStream[classFileOffset++] = OPC_bastore;
 494     } catch (IndexOutOfBoundsException e) {
 495       resizeByteArray(OPC_bastore);
 496     }
 497   }
 498   final public void bipush(byte b) {
 499     countLabels = 0;
 500     stackDepth++;
 501     if (stackDepth > stackMax)
 502       stackMax = stackDepth;
 503     try {
 504       position++;
 505       bCodeStream[classFileOffset++] = OPC_bipush;
 506     } catch (IndexOutOfBoundsException e) {
 507       resizeByteArray(OPC_bipush);
 508     }
 509     writeSignedByte(b);
 510   }
 511   final public void caload() {
 512     countLabels = 0;
 513     stackDepth--;
 514     try {
 515       position++;
 516       bCodeStream[classFileOffset++] = OPC_caload;
 517     } catch (IndexOutOfBoundsException e) {
 518       resizeByteArray(OPC_caload);
 519     }
 520   }
 521   final public void castore() {
 522     countLabels = 0;
 523     stackDepth -= 3;
 524     try {
 525       position++;
 526       bCodeStream[classFileOffset++] = OPC_castore;
 527     } catch (IndexOutOfBoundsException e) {
 528       resizeByteArray(OPC_castore);
 529     }
 530   }
 531   public final void checkcast(TypeBinding typeBinding) {
 532     countLabels = 0;
 533     try {
 534       position++;
 535       bCodeStream[classFileOffset++] = OPC_checkcast;
 536     } catch (IndexOutOfBoundsException e) {
 537       resizeByteArray(OPC_checkcast);
 538     }
 539     writeUnsignedShort(constantPool.literalIndex(typeBinding));
 540   }
 541   public final void checkcastJavaLangError() {
 542     countLabels = 0;
 543     try {
 544       position++;
 545       bCodeStream[classFileOffset++] = OPC_checkcast;
 546     } catch (IndexOutOfBoundsException e) {
 547       resizeByteArray(OPC_checkcast);
 548     }
 549     writeUnsignedShort(constantPool.literalIndexForJavaLangError());
 550   }
 551   final public void d2f() {
 552     countLabels = 0;
 553     stackDepth--;
 554     try {
 555       position++;
 556       bCodeStream[classFileOffset++] = OPC_d2f;
 557     } catch (IndexOutOfBoundsException e) {
 558       resizeByteArray(OPC_d2f);
 559     }
 560   }
 561   final public void d2i() {
 562     countLabels = 0;
 563     stackDepth--;
 564     try {
 565       position++;
 566       bCodeStream[classFileOffset++] = OPC_d2i;
 567     } catch (IndexOutOfBoundsException e) {
 568       resizeByteArray(OPC_d2i);
 569     }
 570   }
 571   final public void d2l() {
 572     countLabels = 0;
 573     try {
 574       position++;
 575       bCodeStream[classFileOffset++] = OPC_d2l;
 576     } catch (IndexOutOfBoundsException e) {
 577       resizeByteArray(OPC_d2l);
 578     }
 579   }
 580   final public void dadd() {
 581     countLabels = 0;
 582     stackDepth -= 2;
 583     try {
 584       position++;
 585       bCodeStream[classFileOffset++] = OPC_dadd;
 586     } catch (IndexOutOfBoundsException e) {
 587       resizeByteArray(OPC_dadd);
 588     }
 589   }
 590   final public void daload() {
 591     countLabels = 0;
 592     try {
 593       position++;
 594       bCodeStream[classFileOffset++] = OPC_daload;
 595     } catch (IndexOutOfBoundsException e) {
 596       resizeByteArray(OPC_daload);
 597     }
 598   }
 599   final public void dastore() {
 600     countLabels = 0;
 601     stackDepth -= 4;
 602     try {
 603       position++;
 604       bCodeStream[classFileOffset++] = OPC_dastore;
 605     } catch (IndexOutOfBoundsException e) {
 606       resizeByteArray(OPC_dastore);
 607     }
 608   }
 609   final public void dcmpg() {
 610     countLabels = 0;
 611     stackDepth -= 3;
 612     try {
 613       position++;
 614       bCodeStream[classFileOffset++] = OPC_dcmpg;
 615     } catch (IndexOutOfBoundsException e) {
 616       resizeByteArray(OPC_dcmpg);
 617     }
 618   }
 619   final public void dcmpl() {
 620     countLabels = 0;
 621     stackDepth -= 3;
 622     try {
 623       position++;
 624       bCodeStream[classFileOffset++] = OPC_dcmpl;
 625     } catch (IndexOutOfBoundsException e) {
 626       resizeByteArray(OPC_dcmpl);
 627     }
 628   }
 629   final public void dconst_0() {
 630     countLabels = 0;
 631     stackDepth += 2;
 632     if (stackDepth > stackMax)
 633       stackMax = stackDepth;
 634     try {
 635       position++;
 636       bCodeStream[classFileOffset++] = OPC_dconst_0;
 637     } catch (IndexOutOfBoundsException e) {
 638       resizeByteArray(OPC_dconst_0);
 639     }
 640   }
 641   final public void dconst_1() {
 642     countLabels = 0;
 643     stackDepth += 2;
 644     if (stackDepth > stackMax)
 645       stackMax = stackDepth;
 646     try {
 647       position++;
 648       bCodeStream[classFileOffset++] = OPC_dconst_1;
 649     } catch (IndexOutOfBoundsException e) {
 650       resizeByteArray(OPC_dconst_1);
 651     }
 652   }
 653   final public void ddiv() {
 654     countLabels = 0;
 655     stackDepth -= 2;
 656     try {
 657       position++;
 658       bCodeStream[classFileOffset++] = OPC_ddiv;
 659     } catch (IndexOutOfBoundsException e) {
 660       resizeByteArray(OPC_ddiv);
 661     }
 662   }
 663   public void decrStackSize(int offset) {
 664     stackDepth -= offset;
 665   }
 666   final public void dload(int iArg) {
 667     countLabels = 0;
 668     stackDepth += 2;
 669     if (stackDepth > stackMax)
 670       stackMax = stackDepth;
 671     if (maxLocals < iArg + 2) {
 672       maxLocals = iArg + 2; // + 2 because it is a double
 673     }
 674     if (iArg > 255) { // Widen
 675       try {
 676         position++;
 677         bCodeStream[classFileOffset++] = OPC_wide;
 678       } catch (IndexOutOfBoundsException e) {
 679         resizeByteArray(OPC_wide);
 680       }
 681       try {
 682         position++;
 683         bCodeStream[classFileOffset++] = OPC_dload;
 684       } catch (IndexOutOfBoundsException e) {
 685         resizeByteArray(OPC_dload);
 686       }
 687       writeUnsignedShort(iArg);
 688     } else {
 689       // Don't need to use the wide bytecode
 690       try {
 691         position++;
 692         bCodeStream[classFileOffset++] = OPC_dload;
 693       } catch (IndexOutOfBoundsException e) {
 694         resizeByteArray(OPC_dload);
 695       }
 696       try {
 697         position++;
 698         bCodeStream[classFileOffset++] = (byte) iArg;
 699       } catch (IndexOutOfBoundsException e) {
 700         resizeByteArray((byte) iArg);
 701       }
 702     }
 703   }
 704   final public void dload_0() {
 705     countLabels = 0;
 706     stackDepth += 2;
 707     if (stackDepth > stackMax)
 708       stackMax = stackDepth;
 709     if (maxLocals < 2) {
 710       maxLocals = 2;
 711     }
 712     try {
 713       position++;
 714       bCodeStream[classFileOffset++] = OPC_dload_0;
 715     } catch (IndexOutOfBoundsException e) {
 716       resizeByteArray(OPC_dload_0);
 717     }
 718   }
 719   final public void dload_1() {
 720     countLabels = 0;
 721     stackDepth += 2;
 722     if (stackDepth > stackMax)
 723       stackMax = stackDepth;
 724     if (maxLocals < 3) {
 725       maxLocals = 3;
 726     }
 727     try {
 728       position++;
 729       bCodeStream[classFileOffset++] = OPC_dload_1;
 730     } catch (IndexOutOfBoundsException e) {
 731       resizeByteArray(OPC_dload_1);
 732     }
 733   }
 734   final public void dload_2() {
 735     countLabels = 0;
 736     stackDepth += 2;
 737     if (stackDepth > stackMax)
 738       stackMax = stackDepth;
 739     if (maxLocals < 4) {
 740       maxLocals = 4;
 741     }
 742     try {
 743       position++;
 744       bCodeStream[classFileOffset++] = OPC_dload_2;
 745     } catch (IndexOutOfBoundsException e) {
 746       resizeByteArray(OPC_dload_2);
 747     }
 748   }
 749   final public void dload_3() {
 750     countLabels = 0;
 751     stackDepth += 2;
 752     if (stackDepth > stackMax)
 753       stackMax = stackDepth;
 754     if (maxLocals < 5) {
 755       maxLocals = 5;
 756     }
 757     try {
 758       position++;
 759       bCodeStream[classFileOffset++] = OPC_dload_3;
 760     } catch (IndexOutOfBoundsException e) {
 761       resizeByteArray(OPC_dload_3);
 762     }
 763   }
 764   final public void dmul() {
 765     countLabels = 0;
 766     stackDepth -= 2;
 767     try {
 768       position++;
 769       bCodeStream[classFileOffset++] = OPC_dmul;
 770     } catch (IndexOutOfBoundsException e) {
 771       resizeByteArray(OPC_dmul);
 772     }
 773   }
 774   final public void dneg() {
 775     countLabels = 0;
 776     try {
 777       position++;
 778       bCodeStream[classFileOffset++] = OPC_dneg;
 779     } catch (IndexOutOfBoundsException e) {
 780       resizeByteArray(OPC_dneg);
 781     }
 782   }
 783   final public void drem() {
 784     countLabels = 0;
 785     stackDepth -= 2;
 786     try {
 787       position++;
 788       bCodeStream[classFileOffset++] = OPC_drem;
 789     } catch (IndexOutOfBoundsException e) {
 790       resizeByteArray(OPC_drem);
 791     }
 792   }
 793   final public void dreturn() {
 794     countLabels = 0;
 795     stackDepth -= 2;
 796     // the stackDepth should be equal to 0
 797     try {
 798       position++;
 799       bCodeStream[classFileOffset++] = OPC_dreturn;
 800     } catch (IndexOutOfBoundsException e) {
 801       resizeByteArray(OPC_dreturn);
 802     }
 803   }
 804   final public void dstore(int iArg) {
 805     countLabels = 0;
 806     stackDepth -= 2;
 807     if (maxLocals <= iArg + 1) {
 808       maxLocals = iArg + 2;
 809     }
 810     if (iArg > 255) { // Widen
 811       try {
 812         position++;
 813         bCodeStream[classFileOffset++] = OPC_wide;
 814       } catch (IndexOutOfBoundsException e) {
 815         resizeByteArray(OPC_wide);
 816       }
 817       try {
 818         position++;
 819         bCodeStream[classFileOffset++] = OPC_dstore;
 820       } catch (IndexOutOfBoundsException e) {
 821         resizeByteArray(OPC_dstore);
 822       }
 823       writeUnsignedShort(iArg);
 824     } else {
 825       try {
 826         position++;
 827         bCodeStream[classFileOffset++] = OPC_dstore;
 828       } catch (IndexOutOfBoundsException e) {
 829         resizeByteArray(OPC_dstore);
 830       }
 831       try {
 832         position++;
 833         bCodeStream[classFileOffset++] = (byte) iArg;
 834       } catch (IndexOutOfBoundsException e) {
 835         resizeByteArray((byte) iArg);
 836       }
 837     }
 838   }
 839   final public void dstore_0() {
 840     countLabels = 0;
 841     stackDepth -= 2;
 842     if (maxLocals < 2) {
 843       maxLocals = 2;
 844     }
 845     try {
 846       position++;
 847       bCodeStream[classFileOffset++] = OPC_dstore_0;
 848     } catch (IndexOutOfBoundsException e) {
 849       resizeByteArray(OPC_dstore_0);
 850     }
 851   }
 852   final public void dstore_1() {
 853     countLabels = 0;
 854     stackDepth -= 2;
 855     if (maxLocals < 3) {
 856       maxLocals = 3;
 857     }
 858     try {
 859       position++;
 860       bCodeStream[classFileOffset++] = OPC_dstore_1;
 861     } catch (IndexOutOfBoundsException e) {
 862       resizeByteArray(OPC_dstore_1);
 863     }
 864   }
 865   final public void dstore_2() {
 866     countLabels = 0;
 867     stackDepth -= 2;
 868     if (maxLocals < 4) {
 869       maxLocals = 4;
 870     }
 871     try {
 872       position++;
 873       bCodeStream[classFileOffset++] = OPC_dstore_2;
 874     } catch (IndexOutOfBoundsException e) {
 875       resizeByteArray(OPC_dstore_2);
 876     }
 877   }
 878   final public void dstore_3() {
 879     countLabels = 0;
 880     stackDepth -= 2;
 881     if (maxLocals < 5) {
 882       maxLocals = 5;
 883     }
 884     try {
 885       position++;
 886       bCodeStream[classFileOffset++] = OPC_dstore_3;
 887     } catch (IndexOutOfBoundsException e) {
 888       resizeByteArray(OPC_dstore_3);
 889     }
 890   }
 891   final public void dsub() {
 892     countLabels = 0;
 893     stackDepth -= 2;
 894     try {
 895       position++;
 896       bCodeStream[classFileOffset++] = OPC_dsub;
 897     } catch (IndexOutOfBoundsException e) {
 898       resizeByteArray(OPC_dsub);
 899     }
 900   }
 901   final public void dup() {
 902     countLabels = 0;
 903     stackDepth++;
 904     if (stackDepth > stackMax)
 905       stackMax = stackDepth;
 906     try {
 907       position++;
 908       bCodeStream[classFileOffset++] = OPC_dup;
 909     } catch (IndexOutOfBoundsException e) {
 910       resizeByteArray(OPC_dup);
 911     }
 912   }
 913   final public void dup_x1() {
 914     countLabels = 0;
 915     stackDepth++;
 916     if (stackDepth > stackMax)
 917       stackMax = stackDepth;
 918     try {
 919       position++;
 920       bCodeStream[classFileOffset++] = OPC_dup_x1;
 921     } catch (IndexOutOfBoundsException e) {
 922       resizeByteArray(OPC_dup_x1);
 923     }
 924   }
 925   final public void dup_x2() {
 926     countLabels = 0;
 927     stackDepth++;
 928     if (stackDepth > stackMax)
 929       stackMax = stackDepth;
 930     try {
 931       position++;
 932       bCodeStream[classFileOffset++] = OPC_dup_x2;
 933     } catch (IndexOutOfBoundsException e) {
 934       resizeByteArray(OPC_dup_x2);
 935     }
 936   }
 937   final public void dup2() {
 938     countLabels = 0;
 939     stackDepth += 2;
 940     if (stackDepth > stackMax)
 941       stackMax = stackDepth;
 942     try {
 943       position++;
 944       bCodeStream[classFileOffset++] = OPC_dup2;
 945     } catch (IndexOutOfBoundsException e) {
 946       resizeByteArray(OPC_dup2);
 947     }
 948   }
 949   final public void dup2_x1() {
 950     countLabels = 0;
 951     stackDepth += 2;
 952     if (stackDepth > stackMax)
 953       stackMax = stackDepth;
 954     try {
 955       position++;
 956       bCodeStream[classFileOffset++] = OPC_dup2_x1;
 957     } catch (IndexOutOfBoundsException e) {
 958       resizeByteArray(OPC_dup2_x1);
 959     }
 960   }
 961   final public void dup2_x2() {
 962     countLabels = 0;
 963     stackDepth += 2;
 964     if (stackDepth > stackMax)
 965       stackMax = stackDepth;
 966     try {
 967       position++;
 968       bCodeStream[classFileOffset++] = OPC_dup2_x2;
 969     } catch (IndexOutOfBoundsException e) {
 970       resizeByteArray(OPC_dup2_x2);
 971     }
 972   }
 973   public void exitUserScope(BlockScope blockScope) {
 974     // mark all the scope's locals as loosing their definite assignment
 975
 976     if (!generateLocalVariableTableAttributes)
 977       return;
 978     for (int i = 0; i < visibleLocalsCount; i++) {
 979       LocalVariableBinding visibleLocal = visibleLocals[i];
 980       if ((visibleLocal != null) && (visibleLocal.declaringScope == blockScope)) {
 981         // there maybe some some preserved locals never initialized
 982         if (visibleLocal.initializationCount > 0) {
 983           visibleLocals[i].recordInitializationEndPC(position);
 984         }
 985         visibleLocals[i] = null; // this variable is no longer visible afterwards
 986       }
 987     }
 988   }
 989   final public void f2d() {
 990     countLabels = 0;
 991     stackDepth++;
 992     if (stackDepth > stackMax)
 993       stackMax = stackDepth;
 994     try {
 995       position++;
 996       bCodeStream[classFileOffset++] = OPC_f2d;
 997     } catch (IndexOutOfBoundsException e) {
 998       resizeByteArray(OPC_f2d);
 999     }
1000   }
1001   final public void f2i() {
1002     countLabels = 0;
1003     try {
1004       position++;
1005       bCodeStream[classFileOffset++] = OPC_f2i;
1006     } catch (IndexOutOfBoundsException e) {
1007       resizeByteArray(OPC_f2i);
1008     }
1009   }
1010   final public void f2l() {
1011     countLabels = 0;
1012     stackDepth++;
1013     if (stackDepth > stackMax)
1014       stackMax = stackDepth;
1015     try {
1016       position++;
1017       bCodeStream[classFileOffset++] = OPC_f2l;
1018     } catch (IndexOutOfBoundsException e) {
1019       resizeByteArray(OPC_f2l);
1020     }
1021   }
1022   final public void fadd() {
1023     countLabels = 0;
1024     stackDepth--;
1025     try {
1026       position++;
1027       bCodeStream[classFileOffset++] = OPC_fadd;
1028     } catch (IndexOutOfBoundsException e) {
1029       resizeByteArray(OPC_fadd);
1030     }
1031   }
1032   final public void faload() {
1033     countLabels = 0;
1034     stackDepth--;
1035     try {
1036       position++;
1037       bCodeStream[classFileOffset++] = OPC_faload;
1038     } catch (IndexOutOfBoundsException e) {
1039       resizeByteArray(OPC_faload);
1040     }
1041   }
1042   final public void fastore() {
1043     countLabels = 0;
1044     stackDepth -= 3;
1045     try {
1046       position++;
1047       bCodeStream[classFileOffset++] = OPC_fastore;
1048     } catch (IndexOutOfBoundsException e) {
1049       resizeByteArray(OPC_fastore);
1050     }
1051   }
1052   final public void fcmpg() {
1053     countLabels = 0;
1054     stackDepth--;
1055     try {
1056       position++;
1057       bCodeStream[classFileOffset++] = OPC_fcmpg;
1058     } catch (IndexOutOfBoundsException e) {
1059       resizeByteArray(OPC_fcmpg);
1060     }
1061   }
1062   final public void fcmpl() {
1063     countLabels = 0;
1064     stackDepth--;
1065     try {
1066       position++;
1067       bCodeStream[classFileOffset++] = OPC_fcmpl;
1068     } catch (IndexOutOfBoundsException e) {
1069       resizeByteArray(OPC_fcmpl);
1070     }
1071   }
1072   final public void fconst_0() {
1073     countLabels = 0;
1074     stackDepth++;
1075     if (stackDepth > stackMax)
1076       stackMax = stackDepth;
1077     try {
1078       position++;
1079       bCodeStream[classFileOffset++] = OPC_fconst_0;
1080     } catch (IndexOutOfBoundsException e) {
1081       resizeByteArray(OPC_fconst_0);
1082     }
1083   }
1084   final public void fconst_1() {
1085     countLabels = 0;
1086     stackDepth++;
1087     if (stackDepth > stackMax)
1088       stackMax = stackDepth;
1089     try {
1090       position++;
1091       bCodeStream[classFileOffset++] = OPC_fconst_1;
1092     } catch (IndexOutOfBoundsException e) {
1093       resizeByteArray(OPC_fconst_1);
1094     }
1095   }
1096   final public void fconst_2() {
1097     countLabels = 0;
1098     stackDepth++;
1099     if (stackDepth > stackMax)
1100       stackMax = stackDepth;
1101     try {
1102       position++;
1103       bCodeStream[classFileOffset++] = OPC_fconst_2;
1104     } catch (IndexOutOfBoundsException e) {
1105       resizeByteArray(OPC_fconst_2);
1106     }
1107   }
1108   final public void fdiv() {
1109     countLabels = 0;
1110     stackDepth--;
1111     try {
1112       position++;
1113       bCodeStream[classFileOffset++] = OPC_fdiv;
1114     } catch (IndexOutOfBoundsException e) {
1115       resizeByteArray(OPC_fdiv);
1116     }
1117   }
1118   final public void fload(int iArg) {
1119     countLabels = 0;
1120     stackDepth++;
1121     if (maxLocals <= iArg) {
1122       maxLocals = iArg + 1;
1123     }
1124     if (stackDepth > stackMax)
1125       stackMax = stackDepth;
1126     if (iArg > 255) { // Widen
1127       try {
1128         position++;
1129         bCodeStream[classFileOffset++] = OPC_wide;
1130       } catch (IndexOutOfBoundsException e) {
1131         resizeByteArray(OPC_wide);
1132       }
1133       try {
1134         position++;
1135         bCodeStream[classFileOffset++] = OPC_fload;
1136       } catch (IndexOutOfBoundsException e) {
1137         resizeByteArray(OPC_fload);
1138       }
1139       writeUnsignedShort(iArg);
1140     } else {
1141       try {
1142         position++;
1143         bCodeStream[classFileOffset++] = OPC_fload;
1144       } catch (IndexOutOfBoundsException e) {
1145         resizeByteArray(OPC_fload);
1146       }
1147       try {
1148         position++;
1149         bCodeStream[classFileOffset++] = (byte) iArg;
1150       } catch (IndexOutOfBoundsException e) {
1151         resizeByteArray((byte) iArg);
1152       }
1153     }
1154   }
1155   final public void fload_0() {
1156     countLabels = 0;
1157     stackDepth++;
1158     if (maxLocals == 0) {
1159       maxLocals = 1;
1160     }
1161     if (stackDepth > stackMax)
1162       stackMax = stackDepth;
1163     try {
1164       position++;
1165       bCodeStream[classFileOffset++] = OPC_fload_0;
1166     } catch (IndexOutOfBoundsException e) {
1167       resizeByteArray(OPC_fload_0);
1168     }
1169   }
1170   final public void fload_1() {
1171     countLabels = 0;
1172     stackDepth++;
1173     if (maxLocals <= 1) {
1174       maxLocals = 2;
1175     }
1176     if (stackDepth > stackMax)
1177       stackMax = stackDepth;
1178     try {
1179       position++;
1180       bCodeStream[classFileOffset++] = OPC_fload_1;
1181     } catch (IndexOutOfBoundsException e) {
1182       resizeByteArray(OPC_fload_1);
1183     }
1184   }
1185   final public void fload_2() {
1186     countLabels = 0;
1187     stackDepth++;
1188     if (maxLocals <= 2) {
1189       maxLocals = 3;
1190     }
1191     if (stackDepth > stackMax)
1192       stackMax = stackDepth;
1193     try {
1194       position++;
1195       bCodeStream[classFileOffset++] = OPC_fload_2;
1196     } catch (IndexOutOfBoundsException e) {
1197       resizeByteArray(OPC_fload_2);
1198     }
1199   }
1200   final public void fload_3() {
1201     countLabels = 0;
1202     stackDepth++;
1203     if (maxLocals <= 3) {
1204       maxLocals = 4;
1205     }
1206     if (stackDepth > stackMax)
1207       stackMax = stackDepth;
1208     try {
1209       position++;
1210       bCodeStream[classFileOffset++] = OPC_fload_3;
1211     } catch (IndexOutOfBoundsException e) {
1212       resizeByteArray(OPC_fload_3);
1213     }
1214   }
1215   final public void fmul() {
1216     countLabels = 0;
1217     stackDepth--;
1218     try {
1219       position++;
1220       bCodeStream[classFileOffset++] = OPC_fmul;
1221     } catch (IndexOutOfBoundsException e) {
1222       resizeByteArray(OPC_fmul);
1223     }
1224   }
1225   final public void fneg() {
1226     countLabels = 0;
1227     try {
1228       position++;
1229       bCodeStream[classFileOffset++] = OPC_fneg;
1230     } catch (IndexOutOfBoundsException e) {
1231       resizeByteArray(OPC_fneg);
1232     }
1233   }
1234   final public void frem() {
1235     countLabels = 0;
1236     stackDepth--;
1237     try {
1238       position++;
1239       bCodeStream[classFileOffset++] = OPC_frem;
1240     } catch (IndexOutOfBoundsException e) {
1241       resizeByteArray(OPC_frem);
1242     }
1243   }
1244   final public void freturn() {
1245     countLabels = 0;
1246     stackDepth--;
1247     // the stackDepth should be equal to 0
1248     try {
1249       position++;
1250       bCodeStream[classFileOffset++] = OPC_freturn;
1251     } catch (IndexOutOfBoundsException e) {
1252       resizeByteArray(OPC_freturn);
1253     }
1254   }
1255   final public void fstore(int iArg) {
1256     countLabels = 0;
1257     stackDepth--;
1258     if (maxLocals <= iArg) {
1259       maxLocals = iArg + 1;
1260     }
1261     if (iArg > 255) { // Widen
1262       try {
1263         position++;
1264         bCodeStream[classFileOffset++] = OPC_wide;
1265       } catch (IndexOutOfBoundsException e) {
1266         resizeByteArray(OPC_wide);
1267       }
1268       try {
1269         position++;
1270         bCodeStream[classFileOffset++] = OPC_fstore;
1271       } catch (IndexOutOfBoundsException e) {
1272         resizeByteArray(OPC_fstore);
1273       }
1274       writeUnsignedShort(iArg);
1275     } else {
1276       try {
1277         position++;
1278         bCodeStream[classFileOffset++] = OPC_fstore;
1279       } catch (IndexOutOfBoundsException e) {
1280         resizeByteArray(OPC_fstore);
1281       }
1282       try {
1283         position++;
1284         bCodeStream[classFileOffset++] = (byte) iArg;
1285       } catch (IndexOutOfBoundsException e) {
1286         resizeByteArray((byte) iArg);
1287       }
1288     }
1289   }
1290   final public void fstore_0() {
1291     countLabels = 0;
1292     stackDepth--;
1293     if (maxLocals == 0) {
1294       maxLocals = 1;
1295     }
1296     try {
1297       position++;
1298       bCodeStream[classFileOffset++] = OPC_fstore_0;
1299     } catch (IndexOutOfBoundsException e) {
1300       resizeByteArray(OPC_fstore_0);
1301     }
1302   }
1303   final public void fstore_1() {
1304     countLabels = 0;
1305     stackDepth--;
1306     if (maxLocals <= 1) {
1307       maxLocals = 2;
1308     }
1309     try {
1310       position++;
1311       bCodeStream[classFileOffset++] = OPC_fstore_1;
1312     } catch (IndexOutOfBoundsException e) {
1313       resizeByteArray(OPC_fstore_1);
1314     }
1315   }
1316   final public void fstore_2() {
1317     countLabels = 0;
1318     stackDepth--;
1319     if (maxLocals <= 2) {
1320       maxLocals = 3;
1321     }
1322     try {
1323       position++;
1324       bCodeStream[classFileOffset++] = OPC_fstore_2;
1325     } catch (IndexOutOfBoundsException e) {
1326       resizeByteArray(OPC_fstore_2);
1327     }
1328   }
1329   final public void fstore_3() {
1330     countLabels = 0;
1331     stackDepth--;
1332     if (maxLocals <= 3) {
1333       maxLocals = 4;
1334     }
1335     try {
1336       position++;
1337       bCodeStream[classFileOffset++] = OPC_fstore_3;
1338     } catch (IndexOutOfBoundsException e) {
1339       resizeByteArray(OPC_fstore_3);
1340     }
1341   }
1342   final public void fsub() {
1343     countLabels = 0;
1344     stackDepth--;
1345     try {
1346       position++;
1347       bCodeStream[classFileOffset++] = OPC_fsub;
1348     } catch (IndexOutOfBoundsException e) {
1349       resizeByteArray(OPC_fsub);
1350     }
1351   }
1352   /**
1353    * Macro for building a class descriptor object
1354    */
1355   public void generateClassLiteralAccessForType(TypeBinding accessedType, FieldBinding syntheticFieldBinding) {
1356     Label endLabel;
1357     ExceptionLabel anyExceptionHandler;
1358     int saveStackSize;
1359     if (accessedType.isBaseType() && accessedType != NullBinding) {
1360       this.getTYPE(accessedType.id);
1361       return;
1362     }
1363     endLabel = new Label(this);
1364
1365     if (syntheticFieldBinding != null) { // non interface case
1366       this.getstatic(syntheticFieldBinding);
1367       this.dup();
1368       this.ifnonnull(endLabel);
1369       this.pop();
1370     }
1371
1372     /* Macro for building a class descriptor object... using or not a field cache to store it into...
1373     this sequence is responsible for building the actual class descriptor.
1374
1375     If the fieldCache is set, then it is supposed to be the body of a synthetic access method
1376     factoring the actual descriptor creation out of the invocation site (saving space).
1377     If the fieldCache is nil, then we are dumping the bytecode on the invocation site, since
1378     we have no way to get a hand on the field cache to do better. */
1379
1380     // Wrap the code in an exception handler to convert a ClassNotFoundException into a NoClassDefError
1381
1382     anyExceptionHandler = new ExceptionLabel(this, TypeBinding.NullBinding /* represents ClassNotFoundException*/
1383     );
1384     this.ldc(accessedType == TypeBinding.NullBinding ? "java.lang.Object" : String.valueOf(accessedType.constantPoolName()).replace('/', '.')); //$NON-NLS-1$
1385     this.invokeClassForName();
1386
1387     /* We need to protect the runtime code from binary inconsistencies
1388     in case the accessedType is missing, the ClassNotFoundException has to be converted
1389     into a NoClassDefError(old ex message), we thus need to build an exception handler for this one. */
1390     anyExceptionHandler.placeEnd();
1391
1392     if (syntheticFieldBinding != null) { // non interface case
1393       this.dup();
1394       this.putstatic(syntheticFieldBinding);
1395     }
1396     this.goto_(endLabel);
1397
1398     // Generate the body of the exception handler
1399     saveStackSize = stackDepth;
1400     stackDepth = 1;
1401     /* ClassNotFoundException on stack -- the class literal could be doing more things
1402     on the stack, which means that the stack may not be empty at this point in the
1403     above code gen. So we save its state and restart it from 1. */
1404
1405     anyExceptionHandler.place();
1406
1407     // Transform the current exception, and repush and throw a
1408     // NoClassDefFoundError(ClassNotFound.getMessage())
1409
1410     this.newNoClassDefFoundError();
1411     this.dup_x1();
1412     this.swap();
1413
1414     // Retrieve the message from the old exception
1415     this.invokeThrowableGetMessage();
1416
1417     // Send the constructor taking a message string as an argument
1418     this.invokeNoClassDefFoundErrorStringConstructor();
1419     this.athrow();
1420     endLabel.place();
1421     stackDepth = saveStackSize;
1422   }
1423   /**
1424    * This method returns the exception handler to be able to generate the exception handler
1425    * attribute.
1426    */
1427   final public int[] generateCodeAttributeForProblemMethod(String errorName, String problemMessage) {
1428     /**
1429      * Equivalent code:
1430      *  try {
1431      *          throw ((Error) (Class.forName(errorName).getConstructor(new Class[] {Class.forName("java.lang.String")})).newInstance(new Object[] {problemMessage}));
1432      *  } catch (Exception e) {
1433      *          throw (NullPointerException) null;
1434      *  }
1435      */
1436     int endPC, handlerPC;
1437     ldc(errorName);
1438     invokeClassForName();
1439     iconst_1();
1440     anewarrayJavaLangClass();
1441     dup();
1442     iconst_0();
1443     ldc("java.lang.String"); //$NON-NLS-1$
1444     invokeClassForName();
1445     aastore();
1446     invokeConstructorGetConstructor();
1447     iconst_1();
1448     anewarrayJavaLangObject();
1449     dup();
1450     iconst_0();
1451     ldc(problemMessage);
1452     aastore();
1453     invokeObjectNewInstance();
1454     checkcastJavaLangError();
1455     athrow();
1456     endPC = handlerPC = position;
1457     pop();
1458     aconst_null();
1459     athrow();
1460     return_();
1461     return new int[] { 0, endPC, handlerPC };
1462   }
1463   public void generateConstant(Constant constant, int implicitConversionCode) {
1464     int targetTypeID = implicitConversionCode >> 4;
1465     switch (targetTypeID) {
1466       case T_boolean :
1467         generateInlinedValue(constant.booleanValue());
1468         break;
1469       case T_char :
1470         generateInlinedValue(constant.charValue());
1471         break;
1472       case T_byte :
1473         generateInlinedValue(constant.byteValue());
1474         break;
1475       case T_short :
1476         generateInlinedValue(constant.shortValue());
1477         break;
1478       case T_int :
1479         generateInlinedValue(constant.intValue());
1480         break;
1481       case T_long :
1482         generateInlinedValue(constant.longValue());
1483         break;
1484       case T_float :
1485         generateInlinedValue(constant.floatValue());
1486         break;
1487       case T_double :
1488         generateInlinedValue(constant.doubleValue());
1489         break;
1490       case T_String :
1491         this.ldc(constant.stringValue());
1492         break;
1493       default : //reference object (constant can be from T_null or T_String)
1494         if (constant.typeID() == T_String)
1495           ldc(constant.stringValue());
1496         else
1497           aconst_null();
1498     }
1499   }
1500   /**
1501    * @param implicitConversionCode int
1502    */
1503   public void generateImplicitConversion(int implicitConversionCode) {
1504     switch (implicitConversionCode) {
1505       case Float2Char :
1506         this.f2i();
1507         this.i2c();
1508         break;
1509       case Double2Char :
1510         this.d2i();
1511         this.i2c();
1512         break;
1513       case Int2Char :
1514       case Short2Char :
1515       case Byte2Char :
1516         this.i2c();
1517         break;
1518       case Long2Char :
1519         this.l2i();
1520         this.i2c();
1521         break;
1522       case Char2Float :
1523       case Short2Float :
1524       case Int2Float :
1525       case Byte2Float :
1526         this.i2f();
1527         break;
1528       case Double2Float :
1529         this.d2f();
1530         break;
1531       case Long2Float :
1532         this.l2f();
1533         break;
1534       case Float2Byte :
1535         this.f2i();
1536         this.i2b();
1537         break;
1538       case Double2Byte :
1539         this.d2i();
1540         this.i2b();
1541         break;
1542       case Int2Byte :
1543       case Short2Byte :
1544       case Char2Byte :
1545         this.i2b();
1546         break;
1547       case Long2Byte :
1548         this.l2i();
1549         this.i2b();
1550         break;
1551       case Byte2Double :
1552       case Char2Double :
1553       case Short2Double :
1554       case Int2Double :
1555         this.i2d();
1556         break;
1557       case Float2Double :
1558         this.f2d();
1559         break;
1560       case Long2Double :
1561         this.l2d();
1562         break;
1563       case Byte2Short :
1564       case Char2Short :
1565       case Int2Short :
1566         this.i2s();
1567         break;
1568       case Double2Short :
1569         this.d2i();
1570         this.i2s();
1571         break;
1572       case Long2Short :
1573         this.l2i();
1574         this.i2s();
1575         break;
1576       case Float2Short :
1577         this.f2i();
1578         this.i2s();
1579         break;
1580       case Double2Int :
1581         this.d2i();
1582         break;
1583       case Float2Int :
1584         this.f2i();
1585         break;
1586       case Long2Int :
1587         this.l2i();
1588         break;
1589       case Int2Long :
1590       case Char2Long :
1591       case Byte2Long :
1592       case Short2Long :
1593         this.i2l();
1594         break;
1595       case Double2Long :
1596         this.d2l();
1597         break;
1598       case Float2Long :
1599         this.f2l();
1600     }
1601   }
1602   public void generateInlinedValue(byte inlinedValue) {
1603     switch (inlinedValue) {
1604       case -1 :
1605         this.iconst_m1();
1606         break;
1607       case 0 :
1608         this.iconst_0();
1609         break;
1610       case 1 :
1611         this.iconst_1();
1612         break;
1613       case 2 :
1614         this.iconst_2();
1615         break;
1616       case 3 :
1617         this.iconst_3();
1618         break;
1619       case 4 :
1620         this.iconst_4();
1621         break;
1622       case 5 :
1623         this.iconst_5();
1624         break;
1625       default :
1626         if ((-128 <= inlinedValue) && (inlinedValue <= 127)) {
1627           this.bipush((byte) inlinedValue);
1628           return;
1629         }
1630     }
1631   }
1632   public void generateInlinedValue(char inlinedValue) {
1633     switch (inlinedValue) {
1634       case 0 :
1635         this.iconst_0();
1636         break;
1637       case 1 :
1638         this.iconst_1();
1639         break;
1640       case 2 :
1641         this.iconst_2();
1642         break;
1643       case 3 :
1644         this.iconst_3();
1645         break;
1646       case 4 :
1647         this.iconst_4();
1648         break;
1649       case 5 :
1650         this.iconst_5();
1651         break;
1652       default :
1653         if ((6 <= inlinedValue) && (inlinedValue <= 127)) {
1654           this.bipush((byte) inlinedValue);
1655           return;
1656         }
1657         if ((128 <= inlinedValue) && (inlinedValue <= 32767)) {
1658           this.sipush(inlinedValue);
1659           return;
1660         }
1661         this.ldc(inlinedValue);
1662     }
1663   }
1664   public void generateInlinedValue(double inlinedValue) {
1665     if (inlinedValue == 0.0) {
1666       if (Double.doubleToLongBits(inlinedValue) != 0L)
1667         this.ldc2_w(inlinedValue);
1668       else
1669         this.dconst_0();
1670       return;
1671     }
1672     if (inlinedValue == 1.0) {
1673       this.dconst_1();
1674       return;
1675     }
1676     this.ldc2_w(inlinedValue);
1677   }
1678   public void generateInlinedValue(float inlinedValue) {
1679     if (inlinedValue == 0.0f) {
1680       if (Float.floatToIntBits(inlinedValue) != 0)
1681         this.ldc(inlinedValue);
1682       else
1683         this.fconst_0();
1684       return;
1685     }
1686     if (inlinedValue == 1.0f) {
1687       this.fconst_1();
1688       return;
1689     }
1690     if (inlinedValue == 2.0f) {
1691       this.fconst_2();
1692       return;
1693     }
1694     this.ldc(inlinedValue);
1695   }
1696   public void generateInlinedValue(int inlinedValue) {
1697     switch (inlinedValue) {
1698       case -1 :
1699         this.iconst_m1();
1700         break;
1701       case 0 :
1702         this.iconst_0();
1703         break;
1704       case 1 :
1705         this.iconst_1();
1706         break;
1707       case 2 :
1708         this.iconst_2();
1709         break;
1710       case 3 :
1711         this.iconst_3();
1712         break;
1713       case 4 :
1714         this.iconst_4();
1715         break;
1716       case 5 :
1717         this.iconst_5();
1718         break;
1719       default :
1720         if ((-128 <= inlinedValue) && (inlinedValue <= 127)) {
1721           this.bipush((byte) inlinedValue);
1722           return;
1723         }
1724         if ((-32768 <= inlinedValue) && (inlinedValue <= 32767)) {
1725           this.sipush(inlinedValue);
1726           return;
1727         }
1728         this.ldc(inlinedValue);
1729     }
1730   }
1731   public void generateInlinedValue(long inlinedValue) {
1732     if (inlinedValue == 0) {
1733       this.lconst_0();
1734       return;
1735     }
1736     if (inlinedValue == 1) {
1737       this.lconst_1();
1738       return;
1739     }
1740     this.ldc2_w(inlinedValue);
1741   }
1742   public void generateInlinedValue(short inlinedValue) {
1743     switch (inlinedValue) {
1744       case -1 :
1745         this.iconst_m1();
1746         break;
1747       case 0 :
1748         this.iconst_0();
1749         break;
1750       case 1 :
1751         this.iconst_1();
1752         break;
1753       case 2 :
1754         this.iconst_2();
1755         break;
1756       case 3 :
1757         this.iconst_3();
1758         break;
1759       case 4 :
1760         this.iconst_4();
1761         break;
1762       case 5 :
1763         this.iconst_5();
1764         break;
1765       default :
1766         if ((-128 <= inlinedValue) && (inlinedValue <= 127)) {
1767           this.bipush((byte) inlinedValue);
1768           return;
1769         }
1770         this.sipush(inlinedValue);
1771     }
1772   }
1773   public void generateInlinedValue(boolean inlinedValue) {
1774     if (inlinedValue)
1775       this.iconst_1();
1776     else
1777       this.iconst_0();
1778   }
1779   public void generateOuterAccess(Object[] mappingSequence, AstNode invocationSite, Scope scope) {
1780     if (mappingSequence == null)
1781       return;
1782     if (mappingSequence == BlockScope.EmulationPathToImplicitThis) {
1783       if (scope.methodScope().isConstructorCall) {
1784         scope.problemReporter().errorThisSuperInStatic(invocationSite);
1785       }
1786       this.aload_0();
1787       return;
1788     }
1789     if (mappingSequence[0] instanceof FieldBinding) {
1790       FieldBinding fieldBinding = (FieldBinding) mappingSequence[0];
1791       if (scope.methodScope().isConstructorCall) {
1792         scope.problemReporter().errorThisSuperInStatic(invocationSite);
1793       }
1794       this.aload_0();
1795       this.getfield(fieldBinding);
1796     } else {
1797       load((LocalVariableBinding) mappingSequence[0]);
1798     }
1799     for (int i = 1, length = mappingSequence.length; i < length; i++) {
1800       if (mappingSequence[i] instanceof FieldBinding) {
1801         FieldBinding fieldBinding = (FieldBinding) mappingSequence[i];
1802         this.getfield(fieldBinding);
1803       } else {
1804         this.invokestatic((MethodBinding) mappingSequence[i]);
1805       }
1806     }
1807   }
1808   /**
1809    * The equivalent code performs a string conversion:
1810    *
1811    * @param oper1 org.eclipse.jdt.internal.compiler.lookup.BlockScope
1812    * @param oper1 org.eclipse.jdt.internal.compiler.ast.Expression
1813    * @param oper2 org.eclipse.jdt.internal.compiler.ast.Expression
1814    */
1815   public void generateStringAppend(BlockScope blockScope, Expression oper1, Expression oper2) {
1816     int pc;
1817     if (oper1 == null) {
1818       /* Operand is already on the stack, and maybe nil:
1819       note type1 is always to  java.lang.String here.*/
1820       this.newStringBuffer();
1821       this.dup_x1();
1822       this.swap();
1823       // If argument is reference type, need to transform it
1824       // into a string (handles null case)
1825       this.invokeStringValueOf(T_Object);
1826       this.invokeStringBufferStringConstructor();
1827     } else {
1828       pc = position;
1829       oper1.generateOptimizedStringBufferCreation(blockScope, this, oper1.implicitConversion & 0xF);
1830       this.recordPositionsFrom(pc, oper1.sourceStart);
1831     }
1832     pc = position;
1833     oper2.generateOptimizedStringBuffer(blockScope, this, oper2.implicitConversion & 0xF);
1834     this.recordPositionsFrom(pc, oper2.sourceStart);
1835     this.invokeStringBufferToString();
1836   }
1837   /**
1838    * Code responsible to generate the suitable code to supply values for the synthetic arguments of
1839    * a constructor invocation of a nested type.
1840    */
1841   public void generateSyntheticArgumentValues(
1842     BlockScope currentScope,
1843     ReferenceBinding targetType,
1844     Expression enclosingInstance,
1845     AstNode invocationSite) {
1846
1847     // perform some emulation work in case there is some and we are inside a local type only
1848     ReferenceBinding[] syntheticArgumentTypes;
1849
1850     // generate the enclosing instance first
1851     if ((syntheticArgumentTypes = targetType.syntheticEnclosingInstanceTypes()) != null) {
1852
1853         ReferenceBinding targetEnclosingType =
1854           targetType.isAnonymousType()
1855             ? targetType.superclass().enclosingType() // supplying enclosing instance for the anonymous type's superclass
1856   : targetType.enclosingType();
1857
1858       for (int i = 0, max = syntheticArgumentTypes.length; i < max; i++) {
1859         ReferenceBinding syntheticArgType = syntheticArgumentTypes[i];
1860         if (enclosingInstance != null && i == 0) {
1861           if (syntheticArgType != targetEnclosingType) {
1862             currentScope.problemReporter().unnecessaryEnclosingInstanceSpecification(enclosingInstance, targetType);
1863           }
1864           //if (currentScope.environment().options.complianceLevel >= CompilerOptions.JDK1_4){
1865           enclosingInstance.generateCode(currentScope, this, true);
1866           if (syntheticArgType == targetEnclosingType) {
1867             this.dup();
1868           }
1869           this.invokeObjectGetClass(); // causes null check for all explicit enclosing instances
1870           this.pop();
1871           //} else {
1872           //    enclosingInstance.generateCode(currentScope, this, syntheticArgType == targetEnclosingType);
1873           //}
1874         } else {
1875           Object[] emulationPath = currentScope.getCompatibleEmulationPath(syntheticArgType);
1876           if (emulationPath == null) {
1877             currentScope.problemReporter().missingEnclosingInstanceSpecification(syntheticArgType, invocationSite);
1878           } else {
1879             this.generateOuterAccess(emulationPath, invocationSite, currentScope);
1880           }
1881         }
1882       }
1883     } else { // we may still have an enclosing instance to consider
1884       if (enclosingInstance != null) {
1885         currentScope.problemReporter().unnecessaryEnclosingInstanceSpecification(enclosingInstance, targetType);
1886         //if (currentScope.environment().options.complianceLevel >= CompilerOptions.JDK1_4){
1887         enclosingInstance.generateCode(currentScope, this, true);
1888         this.invokeObjectGetClass(); // causes null check for all explicit enclosing instances
1889         this.pop();
1890         //} else {
1891         //      enclosingInstance.generateCode(currentScope, this, false); // do not want the value
1892         //}
1893       }
1894     }
1895     // generate the synthetic outer arguments then
1896     SyntheticArgumentBinding syntheticArguments[];
1897     if ((syntheticArguments = targetType.syntheticOuterLocalVariables()) != null) {
1898       for (int i = 0, max = syntheticArguments.length; i < max; i++) {
1899         VariableBinding[] emulationPath = currentScope.getEmulationPath(syntheticArguments[i].actualOuterLocalVariable);
1900         if (emulationPath == null) {
1901           // could not emulate a path to a given outer local variable (internal error)
1902           currentScope.problemReporter().needImplementation();
1903         } else {
1904           this.generateOuterAccess(emulationPath, invocationSite, currentScope);
1905         }
1906       }
1907     }
1908   }
1909   /**
1910    * @param parameters org.eclipse.jdt.internal.compiler.lookup.TypeBinding[]
1911    * @param constructorBinding org.eclipse.jdt.internal.compiler.lookup.MethodBinding
1912    */
1913   public void generateSyntheticBodyForConstructorAccess(SyntheticAccessMethodBinding accessBinding) {
1914
1915     initializeMaxLocals(accessBinding);
1916
1917     MethodBinding constructorBinding = accessBinding.targetMethod;
1918     TypeBinding[] parameters = constructorBinding.parameters;
1919     int length = parameters.length;
1920     int resolvedPosition = 1;
1921     this.aload_0();
1922     if (constructorBinding.declaringClass.isNestedType()) {
1923       NestedTypeBinding nestedType = (NestedTypeBinding) constructorBinding.declaringClass;
1924       SyntheticArgumentBinding[] syntheticArguments = nestedType.syntheticEnclosingInstances();
1925       for (int i = 0; i < (syntheticArguments == null ? 0 : syntheticArguments.length); i++) {
1926         TypeBinding type;
1927         load((type = syntheticArguments[i].type), resolvedPosition);
1928         if ((type == DoubleBinding) || (type == LongBinding))
1929           resolvedPosition += 2;
1930         else
1931           resolvedPosition++;
1932       }
1933       syntheticArguments = nestedType.syntheticOuterLocalVariables();
1934       for (int i = 0; i < (syntheticArguments == null ? 0 : syntheticArguments.length); i++) {
1935         TypeBinding type;
1936         load((type = syntheticArguments[i].type), resolvedPosition);
1937         if ((type == DoubleBinding) || (type == LongBinding))
1938           resolvedPosition += 2;
1939         else
1940           resolvedPosition++;
1941       }
1942     }
1943     for (int i = 0; i < length; i++) {
1944       load(parameters[i], resolvedPosition);
1945       if ((parameters[i] == DoubleBinding) || (parameters[i] == LongBinding))
1946         resolvedPosition += 2;
1947       else
1948         resolvedPosition++;
1949     }
1950     this.invokespecial(constructorBinding);
1951     this.return_();
1952   }
1953   public void generateSyntheticBodyForFieldReadAccess(SyntheticAccessMethodBinding accessBinding) {
1954     initializeMaxLocals(accessBinding);
1955     FieldBinding fieldBinding = accessBinding.targetReadField;
1956     TypeBinding type;
1957     if (fieldBinding.isStatic())
1958       this.getstatic(fieldBinding);
1959     else {
1960       this.aload_0();
1961       this.getfield(fieldBinding);
1962     }
1963     if ((type = fieldBinding.type).isBaseType()) {
1964       if (type == IntBinding)
1965         this.ireturn();
1966       else if (type == FloatBinding)
1967         this.freturn();
1968       else if (type == LongBinding)
1969         this.lreturn();
1970       else if (type == DoubleBinding)
1971         this.dreturn();
1972       else
1973         this.ireturn();
1974     } else
1975       this.areturn();
1976   }
1977   public void generateSyntheticBodyForFieldWriteAccess(SyntheticAccessMethodBinding accessBinding) {
1978     initializeMaxLocals(accessBinding);
1979     FieldBinding fieldBinding = accessBinding.targetWriteField;
1980     if (fieldBinding.isStatic()) {
1981       load(fieldBinding.type, 0);
1982       this.putstatic(fieldBinding);
1983     } else {
1984       this.aload_0();
1985       load(fieldBinding.type, 1);
1986       this.putfield(fieldBinding);
1987     }
1988     this.return_();
1989   }
1990   public void generateSyntheticBodyForMethodAccess(SyntheticAccessMethodBinding accessBinding) {
1991
1992     initializeMaxLocals(accessBinding);
1993     MethodBinding methodBinding = accessBinding.targetMethod;
1994     TypeBinding[] parameters = methodBinding.parameters;
1995     int length = parameters.length;
1996     int resolvedPosition;
1997     if (methodBinding.isStatic())
1998       resolvedPosition = 0;
1999     else {
2000       this.aload_0();
2001       resolvedPosition = 1;
2002     }
2003     for (int i = 0; i < length; i++) {
2004       load(parameters[i], resolvedPosition);
2005       if ((parameters[i] == DoubleBinding) || (parameters[i] == LongBinding))
2006         resolvedPosition += 2;
2007       else
2008         resolvedPosition++;
2009     }
2010     TypeBinding type;
2011     if (methodBinding.isStatic())
2012       this.invokestatic(methodBinding);
2013     else {
2014       if (methodBinding.isConstructor()
2015         || methodBinding.isPrivate() // qualified super "X.super.foo()" targets methods from superclass
2016         || (methodBinding.declaringClass != methodDeclaration.binding.declaringClass)) {
2017         this.invokespecial(methodBinding);
2018       } else {
2019         if (methodBinding.declaringClass.isInterface()) {
2020           this.invokeinterface(methodBinding);
2021         } else {
2022           this.invokevirtual(methodBinding);
2023         }
2024       }
2025     }
2026     if ((type = methodBinding.returnType).isBaseType())
2027       if (type == VoidBinding)
2028         this.return_();
2029       else if (type == IntBinding)
2030         this.ireturn();
2031       else if (type == FloatBinding)
2032         this.freturn();
2033       else if (type == LongBinding)
2034         this.lreturn();
2035       else if (type == DoubleBinding)
2036         this.dreturn();
2037       else
2038         this.ireturn();
2039     else
2040       this.areturn();
2041   }
2042   final public byte[] getContents() {
2043     byte[] contents;
2044     System.arraycopy(bCodeStream, 0, contents = new byte[position], 0, position);
2045     return contents;
2046   }
2047   final public void getfield(FieldBinding fieldBinding) {
2048     countLabels = 0;
2049     if ((fieldBinding.type.id == T_double) || (fieldBinding.type.id == T_long)) {
2050       if (++stackDepth > stackMax)
2051         stackMax = stackDepth;
2052     }
2053     try {
2054       position++;
2055       bCodeStream[classFileOffset++] = OPC_getfield;
2056     } catch (IndexOutOfBoundsException e) {
2057       resizeByteArray(OPC_getfield);
2058     }
2059     writeUnsignedShort(constantPool.literalIndex(fieldBinding));
2060   }
2061   final public void getstatic(FieldBinding fieldBinding) {
2062     countLabels = 0;
2063     if ((fieldBinding.type.id == T_double) || (fieldBinding.type.id == T_long))
2064       stackDepth += 2;
2065     else
2066       stackDepth += 1;
2067     if (stackDepth > stackMax)
2068       stackMax = stackDepth;
2069     try {
2070       position++;
2071       bCodeStream[classFileOffset++] = OPC_getstatic;
2072     } catch (IndexOutOfBoundsException e) {
2073       resizeByteArray(OPC_getstatic);
2074     }
2075     writeUnsignedShort(constantPool.literalIndex(fieldBinding));
2076   }
2077   public void getSystemOut() {
2078     countLabels = 0;
2079     if (++stackDepth > stackMax)
2080       stackMax = stackDepth;
2081     try {
2082       position++;
2083       bCodeStream[classFileOffset++] = OPC_getstatic;
2084     } catch (IndexOutOfBoundsException e) {
2085       resizeByteArray(OPC_getstatic);
2086     }
2087     writeUnsignedShort(constantPool.literalIndexForJavaLangSystemOut());
2088   }
2089   public void getTYPE(int baseTypeID) {
2090     countLabels = 0;
2091     if (++stackDepth > stackMax)
2092       stackMax = stackDepth;
2093     try {
2094       position++;
2095       bCodeStream[classFileOffset++] = OPC_getstatic;
2096     } catch (IndexOutOfBoundsException e) {
2097       resizeByteArray(OPC_getstatic);
2098     }
2099     switch (baseTypeID) {
2100       // getstatic: java.lang.Byte.TYPE
2101       case T_byte :
2102         writeUnsignedShort(constantPool.literalIndexForJavaLangByteTYPE());
2103         break;
2104         // getstatic: java.lang.Short.TYPE
2105       case T_short :
2106         writeUnsignedShort(constantPool.literalIndexForJavaLangShortTYPE());
2107         break;
2108         // getstatic: java.lang.Character.TYPE
2109       case T_char :
2110         writeUnsignedShort(constantPool.literalIndexForJavaLangCharacterTYPE());
2111         break;
2112         // getstatic: java.lang.Integer.TYPE
2113       case T_int :
2114         writeUnsignedShort(constantPool.literalIndexForJavaLangIntegerTYPE());
2115         break;
2116         // getstatic: java.lang.Long.TYPE
2117       case T_long :
2118         writeUnsignedShort(constantPool.literalIndexForJavaLangLongTYPE());
2119         break;
2120         // getstatic: java.lang.Float.TYPE
2121       case T_float :
2122         writeUnsignedShort(constantPool.literalIndexForJavaLangFloatTYPE());
2123         break;
2124         // getstatic: java.lang.Double.TYPE
2125       case T_double :
2126         writeUnsignedShort(constantPool.literalIndexForJavaLangDoubleTYPE());
2127         break;
2128         // getstatic: java.lang.Boolean.TYPE
2129       case T_boolean :
2130         writeUnsignedShort(constantPool.literalIndexForJavaLangBooleanTYPE());
2131         break;
2132         // getstatic: java.lang.Void.TYPE
2133       case T_void :
2134         writeUnsignedShort(constantPool.literalIndexForJavaLangVoidTYPE());
2135         break;
2136     }
2137   }
2138   /**
2139    * We didn't call it goto, because there is a conflit with the goto keyword
2140    */
2141   final public void goto_(Label lbl) {
2142     if (this.wideMode) {
2143       this.goto_w(lbl);
2144       return;
2145     }
2146     try {
2147       lbl.inlineForwardReferencesFromLabelsTargeting(position);
2148       /*
2149        Possible optimization for code such as:
2150        public Object foo() {
2151         boolean b = true;
2152         if (b) {
2153                 if (b)
2154                         return null;
2155         } else {
2156                 if (b) {
2157                         return null;
2158                 }
2159         }
2160         return null;
2161       }
2162       The goto around the else block for the first if will
2163       be unreachable, because the thenClause of the second if
2164       returns.
2165       See inlineForwardReferencesFromLabelsTargeting defined
2166       on the Label class for the remaining part of this
2167       optimization.
2168        if (!lbl.isBranchTarget(position)) {
2169         switch(bCodeStream[classFileOffset-1]) {
2170                 case OPC_return :
2171                 case OPC_areturn:
2172                         return;
2173         }
2174       }*/
2175       position++;
2176       bCodeStream[classFileOffset++] = OPC_goto;
2177     } catch (IndexOutOfBoundsException e) {
2178       resizeByteArray(OPC_goto);
2179     }
2180     lbl.branch();
2181   }
2182
2183   /**
2184    * We didn't call it goto, because there is a conflit with the goto keyword
2185    */
2186   final public void internal_goto_(Label lbl) {
2187     try {
2188       lbl.inlineForwardReferencesFromLabelsTargeting(position);
2189       /*
2190        Possible optimization for code such as:
2191        public Object foo() {
2192         boolean b = true;
2193         if (b) {
2194                 if (b)
2195                         return null;
2196         } else {
2197                 if (b) {
2198                         return null;
2199                 }
2200         }
2201         return null;
2202       }
2203       The goto around the else block for the first if will
2204       be unreachable, because the thenClause of the second if
2205       returns.
2206       See inlineForwardReferencesFromLabelsTargeting defined
2207       on the Label class for the remaining part of this
2208       optimization.
2209        if (!lbl.isBranchTarget(position)) {
2210         switch(bCodeStream[classFileOffset-1]) {
2211                 case OPC_return :
2212                 case OPC_areturn:
2213                         return;
2214         }
2215       }*/
2216       position++;
2217       bCodeStream[classFileOffset++] = OPC_goto;
2218     } catch (IndexOutOfBoundsException e) {
2219       resizeByteArray(OPC_goto);
2220     }
2221     lbl.branch();
2222   }
2223   final public void goto_w(Label lbl) {
2224     try {
2225       position++;
2226       bCodeStream[classFileOffset++] = OPC_goto_w;
2227     } catch (IndexOutOfBoundsException e) {
2228       resizeByteArray(OPC_goto_w);
2229     }
2230     lbl.branchWide();
2231   }
2232   final public void i2b() {
2233     countLabels = 0;
2234     try {
2235       position++;
2236       bCodeStream[classFileOffset++] = OPC_i2b;
2237     } catch (IndexOutOfBoundsException e) {
2238       resizeByteArray(OPC_i2b);
2239     }
2240   }
2241   final public void i2c() {
2242     countLabels = 0;
2243     try {
2244       position++;
2245       bCodeStream[classFileOffset++] = OPC_i2c;
2246     } catch (IndexOutOfBoundsException e) {
2247       resizeByteArray(OPC_i2c);
2248     }
2249   }
2250   final public void i2d() {
2251     countLabels = 0;
2252     stackDepth++;
2253     if (stackDepth > stackMax)
2254       stackMax = stackDepth;
2255     try {
2256       position++;
2257       bCodeStream[classFileOffset++] = OPC_i2d;
2258     } catch (IndexOutOfBoundsException e) {
2259       resizeByteArray(OPC_i2d);
2260     }
2261   }
2262   final public void i2f() {
2263     countLabels = 0;
2264     try {
2265       position++;
2266       bCodeStream[classFileOffset++] = OPC_i2f;
2267     } catch (IndexOutOfBoundsException e) {
2268       resizeByteArray(OPC_i2f);
2269     }
2270   }
2271   final public void i2l() {
2272     countLabels = 0;
2273     stackDepth++;
2274     if (stackDepth > stackMax)
2275       stackMax = stackDepth;
2276     try {
2277       position++;
2278       bCodeStream[classFileOffset++] = OPC_i2l;
2279     } catch (IndexOutOfBoundsException e) {
2280       resizeByteArray(OPC_i2l);
2281     }
2282   }
2283   final public void i2s() {
2284     countLabels = 0;
2285     try {
2286       position++;
2287       bCodeStream[classFileOffset++] = OPC_i2s;
2288     } catch (IndexOutOfBoundsException e) {
2289       resizeByteArray(OPC_i2s);
2290     }
2291   }
2292   final public void iadd() {
2293     countLabels = 0;
2294     stackDepth--;
2295     try {
2296       position++;
2297       bCodeStream[classFileOffset++] = OPC_iadd;
2298     } catch (IndexOutOfBoundsException e) {
2299       resizeByteArray(OPC_iadd);
2300     }
2301   }
2302   final public void iaload() {
2303     countLabels = 0;
2304     stackDepth--;
2305     try {
2306       position++;
2307       bCodeStream[classFileOffset++] = OPC_iaload;
2308     } catch (IndexOutOfBoundsException e) {
2309       resizeByteArray(OPC_iaload);
2310     }
2311   }
2312   final public void iand() {
2313     countLabels = 0;
2314     stackDepth--;
2315     try {
2316       position++;
2317       bCodeStream[classFileOffset++] = OPC_iand;
2318     } catch (IndexOutOfBoundsException e) {
2319       resizeByteArray(OPC_iand);
2320     }
2321   }
2322   final public void iastore() {
2323     countLabels = 0;
2324     stackDepth -= 3;
2325     try {
2326       position++;
2327       bCodeStream[classFileOffset++] = OPC_iastore;
2328     } catch (IndexOutOfBoundsException e) {
2329       resizeByteArray(OPC_iastore);
2330     }
2331   }
2332   final public void iconst_0() {
2333     countLabels = 0;
2334     stackDepth++;
2335     if (stackDepth > stackMax)
2336       stackMax = stackDepth;
2337     try {
2338       position++;
2339       bCodeStream[classFileOffset++] = OPC_iconst_0;
2340     } catch (IndexOutOfBoundsException e) {
2341       resizeByteArray(OPC_iconst_0);
2342     }
2343   }
2344   final public void iconst_1() {
2345     countLabels = 0;
2346     stackDepth++;
2347     if (stackDepth > stackMax)
2348       stackMax = stackDepth;
2349     try {
2350       position++;
2351       bCodeStream[classFileOffset++] = OPC_iconst_1;
2352     } catch (IndexOutOfBoundsException e) {
2353       resizeByteArray(OPC_iconst_1);
2354     }
2355   }
2356   final public void iconst_2() {
2357     countLabels = 0;
2358     stackDepth++;
2359     if (stackDepth > stackMax)
2360       stackMax = stackDepth;
2361     try {
2362       position++;
2363       bCodeStream[classFileOffset++] = OPC_iconst_2;
2364     } catch (IndexOutOfBoundsException e) {
2365       resizeByteArray(OPC_iconst_2);
2366     }
2367   }
2368   final public void iconst_3() {
2369     countLabels = 0;
2370     stackDepth++;
2371     if (stackDepth > stackMax)
2372       stackMax = stackDepth;
2373     try {
2374       position++;
2375       bCodeStream[classFileOffset++] = OPC_iconst_3;
2376     } catch (IndexOutOfBoundsException e) {
2377       resizeByteArray(OPC_iconst_3);
2378     }
2379   }
2380   final public void iconst_4() {
2381     countLabels = 0;
2382     stackDepth++;
2383     if (stackDepth > stackMax)
2384       stackMax = stackDepth;
2385     try {
2386       position++;
2387       bCodeStream[classFileOffset++] = OPC_iconst_4;
2388     } catch (IndexOutOfBoundsException e) {
2389       resizeByteArray(OPC_iconst_4);
2390     }
2391   }
2392   final public void iconst_5() {
2393     countLabels = 0;
2394     stackDepth++;
2395     if (stackDepth > stackMax)
2396       stackMax = stackDepth;
2397     try {
2398       position++;
2399       bCodeStream[classFileOffset++] = OPC_iconst_5;
2400     } catch (IndexOutOfBoundsException e) {
2401       resizeByteArray(OPC_iconst_5);
2402     }
2403   }
2404   final public void iconst_m1() {
2405     countLabels = 0;
2406     stackDepth++;
2407     if (stackDepth > stackMax)
2408       stackMax = stackDepth;
2409     try {
2410       position++;
2411       bCodeStream[classFileOffset++] = OPC_iconst_m1;
2412     } catch (IndexOutOfBoundsException e) {
2413       resizeByteArray(OPC_iconst_m1);
2414     }
2415   }
2416   final public void idiv() {
2417     countLabels = 0;
2418     stackDepth--;
2419     try {
2420       position++;
2421       bCodeStream[classFileOffset++] = OPC_idiv;
2422     } catch (IndexOutOfBoundsException e) {
2423       resizeByteArray(OPC_idiv);
2424     }
2425   }
2426   final public void if_acmpeq(Label lbl) {
2427     countLabels = 0;
2428     stackDepth -= 2;
2429     if (this.wideMode) {
2430       generateWideConditionalBranch(OPC_if_acmpeq, lbl);
2431     } else {
2432       try {
2433         position++;
2434         bCodeStream[classFileOffset++] = OPC_if_acmpeq;
2435       } catch (IndexOutOfBoundsException e) {
2436         resizeByteArray(OPC_if_acmpeq);
2437       }
2438       lbl.branch();
2439     }
2440   }
2441   final public void if_acmpne(Label lbl) {
2442     countLabels = 0;
2443     stackDepth -= 2;
2444     if (this.wideMode) {
2445       generateWideConditionalBranch(OPC_if_acmpne, lbl);
2446     } else {
2447       try {
2448         position++;
2449         bCodeStream[classFileOffset++] = OPC_if_acmpne;
2450       } catch (IndexOutOfBoundsException e) {
2451         resizeByteArray(OPC_if_acmpne);
2452       }
2453       lbl.branch();
2454     }
2455   }
2456   final public void if_icmpeq(Label lbl) {
2457     countLabels = 0;
2458     stackDepth -= 2;
2459     if (this.wideMode) {
2460       generateWideConditionalBranch(OPC_if_icmpeq, lbl);
2461     } else {
2462       try {
2463         position++;
2464         bCodeStream[classFileOffset++] = OPC_if_icmpeq;
2465       } catch (IndexOutOfBoundsException e) {
2466         resizeByteArray(OPC_if_icmpeq);
2467       }
2468       lbl.branch();
2469     }
2470   }
2471   final public void if_icmpge(Label lbl) {
2472     countLabels = 0;
2473     stackDepth -= 2;
2474     if (this.wideMode) {
2475       generateWideConditionalBranch(OPC_if_icmpge, lbl);
2476     } else {
2477       try {
2478         position++;
2479         bCodeStream[classFileOffset++] = OPC_if_icmpge;
2480       } catch (IndexOutOfBoundsException e) {
2481         resizeByteArray(OPC_if_icmpge);
2482       }
2483       lbl.branch();
2484     }
2485   }
2486   final public void if_icmpgt(Label lbl) {
2487     countLabels = 0;
2488     stackDepth -= 2;
2489     if (this.wideMode) {
2490       generateWideConditionalBranch(OPC_if_icmpgt, lbl);
2491     } else {
2492       try {
2493         position++;
2494         bCodeStream[classFileOffset++] = OPC_if_icmpgt;
2495       } catch (IndexOutOfBoundsException e) {
2496         resizeByteArray(OPC_if_icmpgt);
2497       }
2498       lbl.branch();
2499     }
2500   }
2501   final public void if_icmple(Label lbl) {
2502     countLabels = 0;
2503     stackDepth -= 2;
2504     if (this.wideMode) {
2505       generateWideConditionalBranch(OPC_if_icmple, lbl);
2506     } else {
2507       try {
2508         position++;
2509         bCodeStream[classFileOffset++] = OPC_if_icmple;
2510       } catch (IndexOutOfBoundsException e) {
2511         resizeByteArray(OPC_if_icmple);
2512       }
2513       lbl.branch();
2514     }
2515   }
2516   final public void if_icmplt(Label lbl) {
2517     countLabels = 0;
2518     stackDepth -= 2;
2519     if (this.wideMode) {
2520       generateWideConditionalBranch(OPC_if_icmplt, lbl);
2521     } else {
2522       try {
2523         position++;
2524         bCodeStream[classFileOffset++] = OPC_if_icmplt;
2525       } catch (IndexOutOfBoundsException e) {
2526         resizeByteArray(OPC_if_icmplt);
2527       }
2528       lbl.branch();
2529     }
2530   }
2531   final public void if_icmpne(Label lbl) {
2532     countLabels = 0;
2533     stackDepth -= 2;
2534     if (this.wideMode) {
2535       generateWideConditionalBranch(OPC_if_icmpne, lbl);
2536     } else {
2537       try {
2538         position++;
2539         bCodeStream[classFileOffset++] = OPC_if_icmpne;
2540       } catch (IndexOutOfBoundsException e) {
2541         resizeByteArray(OPC_if_icmpne);
2542       }
2543       lbl.branch();
2544     }
2545   }
2546   final public void ifeq(Label lbl) {
2547     countLabels = 0;
2548     stackDepth--;
2549     if (this.wideMode) {
2550       generateWideConditionalBranch(OPC_ifeq, lbl);
2551     } else {
2552       try {
2553         position++;
2554         bCodeStream[classFileOffset++] = OPC_ifeq;
2555       } catch (IndexOutOfBoundsException e) {
2556         resizeByteArray(OPC_ifeq);
2557       }
2558       lbl.branch();
2559     }
2560   }
2561   final public void ifge(Label lbl) {
2562     countLabels = 0;
2563     stackDepth--;
2564     if (this.wideMode) {
2565       generateWideConditionalBranch(OPC_ifge, lbl);
2566     } else {
2567       try {
2568         position++;
2569         bCodeStream[classFileOffset++] = OPC_ifge;
2570       } catch (IndexOutOfBoundsException e) {
2571         resizeByteArray(OPC_ifge);
2572       }
2573       lbl.branch();
2574     }
2575   }
2576   final public void ifgt(Label lbl) {
2577     countLabels = 0;
2578     stackDepth--;
2579     if (this.wideMode) {
2580       generateWideConditionalBranch(OPC_ifgt, lbl);
2581     } else {
2582       try {
2583         position++;
2584         bCodeStream[classFileOffset++] = OPC_ifgt;
2585       } catch (IndexOutOfBoundsException e) {
2586         resizeByteArray(OPC_ifgt);
2587       }
2588       lbl.branch();
2589     }
2590   }
2591   final public void ifle(Label lbl) {
2592     countLabels = 0;
2593     stackDepth--;
2594     if (this.wideMode) {
2595       generateWideConditionalBranch(OPC_ifle, lbl);
2596     } else {
2597       try {
2598         position++;
2599         bCodeStream[classFileOffset++] = OPC_ifle;
2600       } catch (IndexOutOfBoundsException e) {
2601         resizeByteArray(OPC_ifle);
2602       }
2603       lbl.branch();
2604     }
2605   }
2606   final public void iflt(Label lbl) {
2607     countLabels = 0;
2608     stackDepth--;
2609     if (this.wideMode) {
2610       generateWideConditionalBranch(OPC_iflt, lbl);
2611     } else {
2612       try {
2613         position++;
2614         bCodeStream[classFileOffset++] = OPC_iflt;
2615       } catch (IndexOutOfBoundsException e) {
2616         resizeByteArray(OPC_iflt);
2617       }
2618       lbl.branch();
2619     }
2620   }
2621   final public void ifne(Label lbl) {
2622     countLabels = 0;
2623     stackDepth--;
2624     if (this.wideMode) {
2625       generateWideConditionalBranch(OPC_ifne, lbl);
2626     } else {
2627       try {
2628         position++;
2629         bCodeStream[classFileOffset++] = OPC_ifne;
2630       } catch (IndexOutOfBoundsException e) {
2631         resizeByteArray(OPC_ifne);
2632       }
2633       lbl.branch();
2634     }
2635   }
2636   final public void ifnonnull(Label lbl) {
2637     countLabels = 0;
2638     stackDepth--;
2639     if (this.wideMode) {
2640       generateWideConditionalBranch(OPC_ifnonnull, lbl);
2641     } else {
2642       try {
2643         position++;
2644         bCodeStream[classFileOffset++] = OPC_ifnonnull;
2645       } catch (IndexOutOfBoundsException e) {
2646         resizeByteArray(OPC_ifnonnull);
2647       }
2648       lbl.branch();
2649     }
2650   }
2651   final public void ifnull(Label lbl) {
2652     countLabels = 0;
2653     stackDepth--;
2654     if (this.wideMode) {
2655       generateWideConditionalBranch(OPC_ifnull, lbl);
2656     } else {
2657       try {
2658         position++;
2659         bCodeStream[classFileOffset++] = OPC_ifnull;
2660       } catch (IndexOutOfBoundsException e) {
2661         resizeByteArray(OPC_ifnull);
2662       }
2663       lbl.branch();
2664     }
2665   }
2666   final public void iinc(int index, int value) {
2667     countLabels = 0;
2668     if ((index > 255) || (value < -128 || value > 127)) { // have to widen
2669       try {
2670         position++;
2671         bCodeStream[classFileOffset++] = OPC_wide;
2672       } catch (IndexOutOfBoundsException e) {
2673         resizeByteArray(OPC_wide);
2674       }
2675       try {
2676         position++;
2677         bCodeStream[classFileOffset++] = OPC_iinc;
2678       } catch (IndexOutOfBoundsException e) {
2679         resizeByteArray(OPC_iinc);
2680       }
2681       writeUnsignedShort(index);
2682       writeSignedShort(value);
2683     } else {
2684       try {
2685         position++;
2686         bCodeStream[classFileOffset++] = OPC_iinc;
2687       } catch (IndexOutOfBoundsException e) {
2688         resizeByteArray(OPC_iinc);
2689       }
2690       writeUnsignedByte(index);
2691       writeSignedByte(value);
2692     }
2693   }
2694   final public void iload(int iArg) {
2695     countLabels = 0;
2696     stackDepth++;
2697     if (maxLocals <= iArg) {
2698       maxLocals = iArg + 1;
2699     }
2700     if (stackDepth > stackMax)
2701       stackMax = stackDepth;
2702     if (iArg > 255) { // Widen
2703       try {
2704         position++;
2705         bCodeStream[classFileOffset++] = OPC_wide;
2706       } catch (IndexOutOfBoundsException e) {
2707         resizeByteArray(OPC_wide);
2708       }
2709       try {
2710         position++;
2711         bCodeStream[classFileOffset++] = OPC_iload;
2712       } catch (IndexOutOfBoundsException e) {
2713         resizeByteArray(OPC_iload);
2714       }
2715       writeUnsignedShort(iArg);
2716     } else {
2717       try {
2718         position++;
2719         bCodeStream[classFileOffset++] = OPC_iload;
2720       } catch (IndexOutOfBoundsException e) {
2721         resizeByteArray(OPC_iload);
2722       }
2723       try {
2724         position++;
2725         bCodeStream[classFileOffset++] = (byte) iArg;
2726       } catch (IndexOutOfBoundsException e) {
2727         resizeByteArray((byte) iArg);
2728       }
2729     }
2730   }
2731   final public void iload_0() {
2732     countLabels = 0;
2733     stackDepth++;
2734     if (maxLocals <= 0) {
2735       maxLocals = 1;
2736     }
2737     if (stackDepth > stackMax)
2738       stackMax = stackDepth;
2739     try {
2740       position++;
2741       bCodeStream[classFileOffset++] = OPC_iload_0;
2742     } catch (IndexOutOfBoundsException e) {
2743       resizeByteArray(OPC_iload_0);
2744     }
2745   }
2746   final public void iload_1() {
2747     countLabels = 0;
2748     stackDepth++;
2749     if (maxLocals <= 1) {
2750       maxLocals = 2;
2751     }
2752     if (stackDepth > stackMax)
2753       stackMax = stackDepth;
2754     try {
2755       position++;
2756       bCodeStream[classFileOffset++] = OPC_iload_1;
2757     } catch (IndexOutOfBoundsException e) {
2758       resizeByteArray(OPC_iload_1);
2759     }
2760   }
2761   final public void iload_2() {
2762     countLabels = 0;
2763     stackDepth++;
2764     if (maxLocals <= 2) {
2765       maxLocals = 3;
2766     }
2767     if (stackDepth > stackMax)
2768       stackMax = stackDepth;
2769     try {
2770       position++;
2771       bCodeStream[classFileOffset++] = OPC_iload_2;
2772     } catch (IndexOutOfBoundsException e) {
2773       resizeByteArray(OPC_iload_2);
2774     }
2775   }
2776   final public void iload_3() {
2777     countLabels = 0;
2778     stackDepth++;
2779     if (maxLocals <= 3) {
2780       maxLocals = 4;
2781     }
2782     if (stackDepth > stackMax)
2783       stackMax = stackDepth;
2784     try {
2785       position++;
2786       bCodeStream[classFileOffset++] = OPC_iload_3;
2787     } catch (IndexOutOfBoundsException e) {
2788       resizeByteArray(OPC_iload_3);
2789     }
2790   }
2791   final public void imul() {
2792     countLabels = 0;
2793     stackDepth--;
2794     try {
2795       position++;
2796       bCodeStream[classFileOffset++] = OPC_imul;
2797     } catch (IndexOutOfBoundsException e) {
2798       resizeByteArray(OPC_imul);
2799     }
2800   }
2801   public void incrementTemp(LocalVariableBinding localBinding, int value) {
2802     if (value == (short) value) {
2803       this.iinc(localBinding.resolvedPosition, value);
2804       return;
2805     }
2806     load(localBinding);
2807     this.ldc(value);
2808     this.iadd();
2809     store(localBinding, false);
2810   }
2811   public void incrStackSize(int offset) {
2812     if ((stackDepth += offset) > stackMax)
2813       stackMax = stackDepth;
2814   }
2815   public int indexOfSameLineEntrySincePC(int pc, int line) {
2816     for (int index = pc, max = pcToSourceMapSize; index < max; index += 2) {
2817       if (pcToSourceMap[index + 1] == line)
2818         return index;
2819     }
2820     return -1;
2821   }
2822   final public void ineg() {
2823     countLabels = 0;
2824     try {
2825       position++;
2826       bCodeStream[classFileOffset++] = OPC_ineg;
2827     } catch (IndexOutOfBoundsException e) {
2828       resizeByteArray(OPC_ineg);
2829     }
2830   }
2831   public void init(ClassFile classFile) {
2832     this.classFile = classFile;
2833     this.constantPool = classFile.constantPool;
2834     this.bCodeStream = classFile.contents;
2835     this.classFileOffset = classFile.contentsOffset;
2836     this.startingClassFileOffset = this.classFileOffset;
2837     pcToSourceMapSize = 0;
2838     lastEntryPC = 0;
2839     int length = visibleLocals.length;
2840     if (noVisibleLocals.length < length) {
2841       noVisibleLocals = new LocalVariableBinding[length];
2842     }
2843     System.arraycopy(noVisibleLocals, 0, visibleLocals, 0, length);
2844     visibleLocalsCount = 0;
2845
2846     length = locals.length;
2847     if (noLocals.length < length) {
2848       noLocals = new LocalVariableBinding[length];
2849     }
2850     System.arraycopy(noLocals, 0, locals, 0, length);
2851     allLocalsCounter = 0;
2852
2853     length = exceptionHandlers.length;
2854     if (noExceptionHandlers.length < length) {
2855       noExceptionHandlers = new ExceptionLabel[length];
2856     }
2857     System.arraycopy(noExceptionHandlers, 0, exceptionHandlers, 0, length);
2858     exceptionHandlersNumber = 0;
2859
2860     length = labels.length;
2861     if (noLabels.length < length) {
2862       noLabels = new Label[length];
2863     }
2864     System.arraycopy(noLabels, 0, labels, 0, length);
2865     countLabels = 0;
2866
2867     stackMax = 0;
2868     stackDepth = 0;
2869     maxLocals = 0;
2870     position = 0;
2871   }
2872   /**
2873    * @param methodDeclaration org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration
2874    * @param classFile org.eclipse.jdt.internal.compiler.codegen.ClassFile
2875    */
2876   public void initializeMaxLocals(MethodBinding methodBinding) {
2877
2878     maxLocals = (methodBinding == null || methodBinding.isStatic()) ? 0 : 1;
2879     // take into account the synthetic parameters
2880     if (methodBinding != null) {
2881       if (methodBinding.isConstructor() && methodBinding.declaringClass.isNestedType()) {
2882         ReferenceBinding enclosingInstanceTypes[];
2883         if ((enclosingInstanceTypes = methodBinding.declaringClass.syntheticEnclosingInstanceTypes()) != null) {
2884           for (int i = 0, max = enclosingInstanceTypes.length; i < max; i++) {
2885             maxLocals++; // an enclosingInstanceType can only be a reference binding. It cannot be
2886             // LongBinding or DoubleBinding
2887           }
2888         }
2889         SyntheticArgumentBinding syntheticArguments[];
2890         if ((syntheticArguments = methodBinding.declaringClass.syntheticOuterLocalVariables()) != null) {
2891           for (int i = 0, max = syntheticArguments.length; i < max; i++) {
2892             TypeBinding argType;
2893             if (((argType = syntheticArguments[i].type) == LongBinding) || (argType == DoubleBinding)) {
2894               maxLocals += 2;
2895             } else {
2896               maxLocals++;
2897             }
2898           }
2899         }
2900       }
2901       TypeBinding[] arguments;
2902       if ((arguments = methodBinding.parameters) != null) {
2903         for (int i = 0, max = arguments.length; i < max; i++) {
2904           TypeBinding argType;
2905           if (((argType = arguments[i]) == LongBinding) || (argType == DoubleBinding)) {
2906             maxLocals += 2;
2907           } else {
2908             maxLocals++;
2909           }
2910         }
2911       }
2912     }
2913   }
2914   /**
2915    * This methods searches for an existing entry inside the pcToSourceMap table with a pc equals to @pc.
2916    * If there is an existing entry it returns -1 (no insertion required).
2917    * Otherwise it returns the index where the entry for the pc has to be inserted.
2918    * This is based on the fact that the pcToSourceMap table is sorted according to the pc.
2919    *
2920    * @param int pc
2921    * @return int
2922    */
2923   public static int insertionIndex(int[] pcToSourceMap, int length, int pc) {
2924     int g = 0;
2925     int d = length - 2;
2926     int m = 0;
2927     while (g <= d) {
2928       m = (g + d) / 2;
2929       // we search only on even indexes
2930       if ((m % 2) != 0)
2931         m--;
2932       int currentPC = pcToSourceMap[m];
2933       if (pc < currentPC) {
2934         d = m - 2;
2935       } else if (pc > currentPC) {
2936         g = m + 2;
2937       } else {
2938         return -1;
2939       }
2940     }
2941     if (pc < pcToSourceMap[m])
2942       return m;
2943     return m + 2;
2944   }
2945   /**
2946    * We didn't call it instanceof because there is a conflit with the
2947    * instanceof keyword
2948    */
2949   final public void instance_of(TypeBinding typeBinding) {
2950     countLabels = 0;
2951     try {
2952       position++;
2953       bCodeStream[classFileOffset++] = OPC_instanceof;
2954     } catch (IndexOutOfBoundsException e) {
2955       resizeByteArray(OPC_instanceof);
2956     }
2957     writeUnsignedShort(constantPool.literalIndex(typeBinding));
2958   }
2959   public void invokeClassForName() {
2960     // invokestatic: java.lang.Class.forName(Ljava.lang.String;)Ljava.lang.Class;
2961     countLabels = 0;
2962     try {
2963       position++;
2964       bCodeStream[classFileOffset++] = OPC_invokestatic;
2965     } catch (IndexOutOfBoundsException e) {
2966       resizeByteArray(OPC_invokestatic);
2967     }
2968     writeUnsignedShort(constantPool.literalIndexForJavaLangClassForName());
2969   }
2970
2971   public void invokeJavaLangClassDesiredAssertionStatus() {
2972     // invokevirtual: java.lang.Class.desiredAssertionStatus()Z;
2973     countLabels = 0;
2974     stackDepth--;
2975     try {
2976       position++;
2977       bCodeStream[classFileOffset++] = OPC_invokevirtual;
2978     } catch (IndexOutOfBoundsException e) {
2979       resizeByteArray(OPC_invokevirtual);
2980     }
2981     writeUnsignedShort(constantPool.literalIndexForJavaLangClassDesiredAssertionStatus());
2982   }
2983
2984   public void invokeConstructorGetConstructor() {
2985     // invokevirtual: java.lang.Class.getConstructor(java.lang.Class[])Ljava.lang.reflect.Constructor;
2986     countLabels = 0;
2987     stackDepth--;
2988     try {
2989       position++;
2990       bCodeStream[classFileOffset++] = OPC_invokevirtual;
2991     } catch (IndexOutOfBoundsException e) {
2992       resizeByteArray(OPC_invokevirtual);
2993     }
2994     writeUnsignedShort(constantPool.literalIndexForJavaLangClassGetConstructor());
2995   }
2996   final public void invokeinterface(MethodBinding methodBinding) {
2997     // initialized to 1 to take into account this  immediately
2998     countLabels = 0;
2999     int argCount = 1;
3000     int id;
3001     try {
3002       position++;
3003       bCodeStream[classFileOffset++] = OPC_invokeinterface;
3004     } catch (IndexOutOfBoundsException e) {
3005       resizeByteArray(OPC_invokeinterface);
3006     }
3007     writeUnsignedShort(constantPool.literalIndex(methodBinding));
3008     for (int i = methodBinding.parameters.length - 1; i >= 0; i--)
3009       if (((id = methodBinding.parameters[i].id) == T_double) || (id == T_long))
3010         argCount += 2;
3011       else
3012         argCount += 1;
3013     writeUnsignedByte(argCount);
3014     // Generate a  0 into the byte array. Like the array is already fill with 0, we just need to increment
3015     // the number of bytes.
3016     position++;
3017     classFileOffset++;
3018     if (((id = methodBinding.returnType.id) == T_double) || (id == T_long))
3019       stackDepth += (2 - argCount);
3020     else if (id == T_void)
3021       stackDepth -= argCount;
3022     else
3023       stackDepth += (1 - argCount);
3024     if (stackDepth > stackMax)
3025       stackMax = stackDepth;
3026   }
3027   public void invokeJavaLangErrorConstructor() {
3028     // invokespecial: java.lang.Error<init>(Ljava.lang.String;)V
3029     countLabels = 0;
3030     try {
3031       position++;
3032       bCodeStream[classFileOffset++] = OPC_invokespecial;
3033     } catch (IndexOutOfBoundsException e) {
3034       resizeByteArray(OPC_invokespecial);
3035     }
3036     stackDepth -= 2;
3037     writeUnsignedShort(constantPool.literalIndexForJavaLangErrorConstructor());
3038   }
3039   public void invokeNoClassDefFoundErrorStringConstructor() {
3040     // invokespecial: java.lang.NoClassDefFoundError.<init>(Ljava.lang.String;)V
3041     countLabels = 0;
3042     try {
3043       position++;
3044       bCodeStream[classFileOffset++] = OPC_invokespecial;
3045     } catch (IndexOutOfBoundsException e) {
3046       resizeByteArray(OPC_invokespecial);
3047     }
3048     writeUnsignedShort(constantPool.literalIndexForJavaLangNoClassDefFoundErrorStringConstructor());
3049     stackDepth -= 2;
3050   }
3051   public void invokeObjectNewInstance() {
3052     // invokevirtual: java.lang.reflect.Constructor.newInstance(java.lang.Object[])Ljava.lang.Object;
3053     countLabels = 0;
3054     stackDepth--;
3055     try {
3056       position++;
3057       bCodeStream[classFileOffset++] = OPC_invokevirtual;
3058     } catch (IndexOutOfBoundsException e) {
3059       resizeByteArray(OPC_invokevirtual);
3060     }
3061     writeUnsignedShort(constantPool.literalIndexForJavaLangReflectConstructorNewInstance());
3062   }
3063
3064   public void invokeObjectGetClass() {
3065     // invokevirtual: java.lang.Object.getClass()Ljava.lang.Class;
3066     countLabels = 0;
3067     try {
3068       position++;
3069       bCodeStream[classFileOffset++] = OPC_invokevirtual;
3070     } catch (IndexOutOfBoundsException e) {
3071       resizeByteArray(OPC_invokevirtual);
3072     }
3073     writeUnsignedShort(constantPool.literalIndexForJavaLangObjectGetClass());
3074   }
3075
3076   final public void invokespecial(MethodBinding methodBinding) {
3077     // initialized to 1 to take into account this  immediately
3078     countLabels = 0;
3079     int argCount = 1;
3080     int id;
3081     try {
3082       position++;
3083       bCodeStream[classFileOffset++] = OPC_invokespecial;
3084     } catch (IndexOutOfBoundsException e) {
3085       resizeByteArray(OPC_invokespecial);
3086     }
3087     writeUnsignedShort(constantPool.literalIndex(methodBinding));
3088     if (methodBinding.isConstructor() && methodBinding.declaringClass.isNestedType()) {
3089       // enclosing instances
3090       TypeBinding[] syntheticArgumentTypes = methodBinding.declaringClass.syntheticEnclosingInstanceTypes();
3091       if (syntheticArgumentTypes != null) {
3092         for (int i = 0, max = syntheticArgumentTypes.length; i < max; i++) {
3093           if (((id = syntheticArgumentTypes[i].id) == T_double) || (id == T_long)) {
3094             argCount += 2;
3095           } else {
3096             argCount++;
3097           }
3098         }
3099       }
3100       // outer local variables
3101       SyntheticArgumentBinding[] syntheticArguments = methodBinding.declaringClass.syntheticOuterLocalVariables();
3102       if (syntheticArguments != null) {
3103         for (int i = 0, max = syntheticArguments.length; i < max; i++) {
3104           if (((id = syntheticArguments[i].type.id) == T_double) || (id == T_long)) {
3105             argCount += 2;
3106           } else {
3107             argCount++;
3108           }
3109         }
3110       }
3111     }
3112     for (int i = methodBinding.parameters.length - 1; i >= 0; i--)
3113       if (((id = methodBinding.parameters[i].id) == T_double) || (id == T_long))
3114         argCount += 2;
3115       else
3116         argCount++;
3117     if (((id = methodBinding.returnType.id) == T_double) || (id == T_long))
3118       stackDepth += (2 - argCount);
3119     else if (id == T_void)
3120       stackDepth -= argCount;
3121     else
3122       stackDepth += (1 - argCount);
3123     if (stackDepth > stackMax)
3124       stackMax = stackDepth;
3125   }
3126   final public void invokestatic(MethodBinding methodBinding) {
3127     // initialized to 0 to take into account that there is no this for
3128     // a static method
3129     countLabels = 0;
3130     int argCount = 0;
3131     int id;
3132     try {
3133       position++;
3134       bCodeStream[classFileOffset++] = OPC_invokestatic;
3135     } catch (IndexOutOfBoundsException e) {
3136       resizeByteArray(OPC_invokestatic);
3137     }
3138     writeUnsignedShort(constantPool.literalIndex(methodBinding));
3139     for (int i = methodBinding.parameters.length - 1; i >= 0; i--)
3140       if (((id = methodBinding.parameters[i].id) == T_double) || (id == T_long))
3141         argCount += 2;
3142       else
3143         argCount += 1;
3144     if (((id = methodBinding.returnType.id) == T_double) || (id == T_long))
3145       stackDepth += (2 - argCount);
3146     else if (id == T_void)
3147       stackDepth -= argCount;
3148     else
3149       stackDepth += (1 - argCount);
3150     if (stackDepth > stackMax)
3151       stackMax = stackDepth;
3152   }
3153   /**
3154    * The equivalent code performs a string conversion of the TOS
3155    * @param typeID <CODE>int</CODE>
3156    */
3157   public void invokeStringBufferAppendForType(int typeID) {
3158     countLabels = 0;
3159     int usedTypeID;
3160     if (typeID == T_null)
3161       usedTypeID = T_String;
3162     else
3163       usedTypeID = typeID;
3164     // invokevirtual
3165     try {
3166       position++;
3167       bCodeStream[classFileOffset++] = OPC_invokevirtual;
3168     } catch (IndexOutOfBoundsException e) {
3169       resizeByteArray(OPC_invokevirtual);
3170     }
3171     writeUnsignedShort(constantPool.literalIndexForJavaLangStringBufferAppend(typeID));
3172     if ((usedTypeID == T_long) || (usedTypeID == T_double))
3173       stackDepth -= 2;
3174     else
3175       stackDepth--;
3176   }
3177
3178   public void invokeJavaLangAssertionErrorConstructor(int typeBindingID) {
3179     // invokespecial: java.lang.AssertionError.<init>(typeBindingID)V
3180     countLabels = 0;
3181     try {
3182       position++;
3183       bCodeStream[classFileOffset++] = OPC_invokespecial;
3184     } catch (IndexOutOfBoundsException e) {
3185       resizeByteArray(OPC_invokespecial);
3186     }
3187     writeUnsignedShort(constantPool.literalIndexForJavaLangAssertionErrorConstructor(typeBindingID));
3188     stackDepth -= 2;
3189   }
3190
3191   public void invokeJavaLangAssertionErrorDefaultConstructor() {
3192     // invokespecial: java.lang.AssertionError.<init>()V
3193     countLabels = 0;
3194     try {
3195       position++;
3196       bCodeStream[classFileOffset++] = OPC_invokespecial;
3197     } catch (IndexOutOfBoundsException e) {
3198       resizeByteArray(OPC_invokespecial);
3199     }
3200     writeUnsignedShort(constantPool.literalIndexForJavaLangAssertionErrorDefaultConstructor());
3201     stackDepth--;
3202   }
3203
3204   public void invokeStringBufferDefaultConstructor() {
3205     // invokespecial: java.lang.StringBuffer.<init>()V
3206     countLabels = 0;
3207     try {
3208       position++;
3209       bCodeStream[classFileOffset++] = OPC_invokespecial;
3210     } catch (IndexOutOfBoundsException e) {
3211       resizeByteArray(OPC_invokespecial);
3212     }
3213     writeUnsignedShort(constantPool.literalIndexForJavaLangStringBufferDefaultConstructor());
3214     stackDepth--;
3215   }
3216   public void invokeStringBufferStringConstructor() {
3217     // invokespecial: java.lang.StringBuffer.<init>(Ljava.lang.String;)V
3218     countLabels = 0;
3219     try {
3220       position++;
3221       bCodeStream[classFileOffset++] = OPC_invokespecial;
3222     } catch (IndexOutOfBoundsException e) {
3223       resizeByteArray(OPC_invokespecial);
3224     }
3225     writeUnsignedShort(constantPool.literalIndexForJavaLangStringBufferConstructor());
3226     stackDepth -= 2;
3227   }
3228
3229   public void invokeStringBufferToString() {
3230     // invokevirtual: StringBuffer.toString()Ljava.lang.String;
3231     countLabels = 0;
3232     try {
3233       position++;
3234       bCodeStream[classFileOffset++] = OPC_invokevirtual;
3235     } catch (IndexOutOfBoundsException e) {
3236       resizeByteArray(OPC_invokevirtual);
3237     }
3238     writeUnsignedShort(constantPool.literalIndexForJavaLangStringBufferToString());
3239   }
3240   public void invokeStringIntern() {
3241     // invokevirtual: java.lang.String.intern()
3242     countLabels = 0;
3243     try {
3244       position++;
3245       bCodeStream[classFileOffset++] = OPC_invokevirtual;
3246     } catch (IndexOutOfBoundsException e) {
3247       resizeByteArray(OPC_invokevirtual);
3248     }
3249     writeUnsignedShort(constantPool.literalIndexForJavaLangStringIntern());
3250   }
3251   public void invokeStringValueOf(int typeID) {
3252     // invokestatic: java.lang.String.valueOf(argumentType)
3253     countLabels = 0;
3254     try {
3255       position++;
3256       bCodeStream[classFileOffset++] = OPC_invokestatic;
3257     } catch (IndexOutOfBoundsException e) {
3258       resizeByteArray(OPC_invokestatic);
3259     }
3260     writeUnsignedShort(constantPool.literalIndexForJavaLangStringValueOf(typeID));
3261   }
3262   public void invokeSystemExit() {
3263     // invokestatic: java.lang.System.exit(I)
3264     countLabels = 0;
3265     try {
3266       position++;
3267       bCodeStream[classFileOffset++] = OPC_invokestatic;
3268     } catch (IndexOutOfBoundsException e) {
3269       resizeByteArray(OPC_invokestatic);
3270     }
3271     writeUnsignedShort(constantPool.literalIndexForJavaLangSystemExitInt());
3272     stackDepth--; // int argument
3273   }
3274   public void invokeThrowableGetMessage() {
3275     // invokevirtual: java.lang.Throwable.getMessage()Ljava.lang.String;
3276     countLabels = 0;
3277     try {
3278       position++;
3279       bCodeStream[classFileOffset++] = OPC_invokevirtual;
3280     } catch (IndexOutOfBoundsException e) {
3281       resizeByteArray(OPC_invokevirtual);
3282     }
3283     writeUnsignedShort(constantPool.literalIndexForJavaLangThrowableGetMessage());
3284   }
3285   final public void invokevirtual(MethodBinding methodBinding) {
3286     // initialized to 1 to take into account this  immediately
3287     countLabels = 0;
3288     int argCount = 1;
3289     int id;
3290     try {
3291       position++;
3292       bCodeStream[classFileOffset++] = OPC_invokevirtual;
3293     } catch (IndexOutOfBoundsException e) {
3294       resizeByteArray(OPC_invokevirtual);
3295     }
3296     writeUnsignedShort(constantPool.literalIndex(methodBinding));
3297     for (int i = methodBinding.parameters.length - 1; i >= 0; i--)
3298       if (((id = methodBinding.parameters[i].id) == T_double) || (id == T_long))
3299         argCount += 2;
3300       else
3301         argCount++;
3302     if (((id = methodBinding.returnType.id) == T_double) || (id == T_long))
3303       stackDepth += (2 - argCount);
3304     else if (id == T_void)
3305       stackDepth -= argCount;
3306     else
3307       stackDepth += (1 - argCount);
3308     if (stackDepth > stackMax)
3309       stackMax = stackDepth;
3310   }
3311   final public void ior() {
3312     countLabels = 0;
3313     stackDepth--;
3314     try {
3315       position++;
3316       bCodeStream[classFileOffset++] = OPC_ior;
3317     } catch (IndexOutOfBoundsException e) {
3318       resizeByteArray(OPC_ior);
3319     }
3320   }
3321   final public void irem() {
3322     countLabels = 0;
3323     stackDepth--;
3324     try {
3325       position++;
3326       bCodeStream[classFileOffset++] = OPC_irem;
3327     } catch (IndexOutOfBoundsException e) {
3328       resizeByteArray(OPC_irem);
3329     }
3330   }
3331   final public void ireturn() {
3332     countLabels = 0;
3333     stackDepth--;
3334     // the stackDepth should be equal to 0
3335     try {
3336       position++;
3337       bCodeStream[classFileOffset++] = OPC_ireturn;
3338     } catch (IndexOutOfBoundsException e) {
3339       resizeByteArray(OPC_ireturn);
3340     }
3341   }
3342   public boolean isDefinitelyAssigned(Scope scope, int initStateIndex, LocalVariableBinding local) {
3343     // Dependant of UnconditionalFlowInfo.isDefinitelyAssigned(..)
3344     if (initStateIndex == -1)
3345       return false;
3346     if (local.isArgument) {
3347       return true;
3348     }
3349     int position = local.id + maxFieldCount;
3350     MethodScope methodScope = scope.methodScope();
3351     // id is zero-based
3352     if (position < UnconditionalFlowInfo.BitCacheSize) {
3353       return (methodScope.definiteInits[initStateIndex] & (1L << position)) != 0; // use bits
3354     }
3355     // use extra vector
3356     long[] extraInits = methodScope.extraDefiniteInits[initStateIndex];
3357     if (extraInits == null)
3358       return false; // if vector not yet allocated, then not initialized
3359     int vectorIndex;
3360     if ((vectorIndex = (position / UnconditionalFlowInfo.BitCacheSize) - 1) >= extraInits.length)
3361       return false; // if not enough room in vector, then not initialized
3362     return ((extraInits[vectorIndex]) & (1L << (position % UnconditionalFlowInfo.BitCacheSize))) != 0;
3363   }
3364   final public void ishl() {
3365     countLabels = 0;
3366     stackDepth--;
3367     try {
3368       position++;
3369       bCodeStream[classFileOffset++] = OPC_ishl;
3370     } catch (IndexOutOfBoundsException e) {
3371       resizeByteArray(OPC_ishl);
3372     }
3373   }
3374   final public void ishr() {
3375     countLabels = 0;
3376     stackDepth--;
3377     try {
3378       position++;
3379       bCodeStream[classFileOffset++] = OPC_ishr;
3380     } catch (IndexOutOfBoundsException e) {
3381       resizeByteArray(OPC_ishr);
3382     }
3383   }
3384   final public void istore(int iArg) {
3385     countLabels = 0;
3386     stackDepth--;
3387     if (maxLocals <= iArg) {
3388       maxLocals = iArg + 1;
3389     }
3390     if (iArg > 255) { // Widen
3391       try {
3392         position++;
3393         bCodeStream[classFileOffset++] = OPC_wide;
3394       } catch (IndexOutOfBoundsException e) {
3395         resizeByteArray(OPC_wide);
3396       }
3397       try {
3398         position++;
3399         bCodeStream[classFileOffset++] = OPC_istore;
3400       } catch (IndexOutOfBoundsException e) {
3401         resizeByteArray(OPC_istore);
3402       }
3403       writeUnsignedShort(iArg);
3404     } else {
3405       try {
3406         position++;
3407         bCodeStream[classFileOffset++] = OPC_istore;
3408       } catch (IndexOutOfBoundsException e) {
3409         resizeByteArray(OPC_istore);
3410       }
3411       try {
3412         position++;
3413         bCodeStream[classFileOffset++] = (byte) iArg;
3414       } catch (IndexOutOfBoundsException e) {
3415         resizeByteArray((byte) iArg);
3416       }
3417     }
3418   }
3419   final public void istore_0() {
3420     countLabels = 0;
3421     stackDepth--;
3422     if (maxLocals == 0) {
3423       maxLocals = 1;
3424     }
3425     try {
3426       position++;
3427       bCodeStream[classFileOffset++] = OPC_istore_0;
3428     } catch (IndexOutOfBoundsException e) {
3429       resizeByteArray(OPC_istore_0);
3430     }
3431   }
3432   final public void istore_1() {
3433     countLabels = 0;
3434     stackDepth--;
3435     if (maxLocals <= 1) {
3436       maxLocals = 2;
3437     }
3438     try {
3439       position++;
3440       bCodeStream[classFileOffset++] = OPC_istore_1;
3441     } catch (IndexOutOfBoundsException e) {
3442       resizeByteArray(OPC_istore_1);
3443     }
3444   }
3445   final public void istore_2() {
3446     countLabels = 0;
3447     stackDepth--;
3448     if (maxLocals <= 2) {
3449       maxLocals = 3;
3450     }
3451     try {
3452       position++;
3453       bCodeStream[classFileOffset++] = OPC_istore_2;
3454     } catch (IndexOutOfBoundsException e) {
3455       resizeByteArray(OPC_istore_2);
3456     }
3457   }
3458   final public void istore_3() {
3459     countLabels = 0;
3460     stackDepth--;
3461     if (maxLocals <= 3) {
3462       maxLocals = 4;
3463     }
3464     try {
3465       position++;
3466       bCodeStream[classFileOffset++] = OPC_istore_3;
3467     } catch (IndexOutOfBoundsException e) {
3468       resizeByteArray(OPC_istore_3);
3469     }
3470   }
3471   final public void isub() {
3472     countLabels = 0;
3473     stackDepth--;
3474     try {
3475       position++;
3476       bCodeStream[classFileOffset++] = OPC_isub;
3477     } catch (IndexOutOfBoundsException e) {
3478       resizeByteArray(OPC_isub);
3479     }
3480   }
3481   final public void iushr() {
3482     countLabels = 0;
3483     stackDepth--;
3484     try {
3485       position++;
3486       bCodeStream[classFileOffset++] = OPC_iushr;
3487     } catch (IndexOutOfBoundsException e) {
3488       resizeByteArray(OPC_iushr);
3489     }
3490   }
3491   final public void ixor() {
3492     countLabels = 0;
3493     stackDepth--;
3494     try {
3495       position++;
3496       bCodeStream[classFileOffset++] = OPC_ixor;
3497     } catch (IndexOutOfBoundsException e) {
3498       resizeByteArray(OPC_ixor);
3499     }
3500   }
3501   final public void jsr(Label lbl) {
3502     countLabels = 0;
3503     try {
3504       position++;
3505       bCodeStream[classFileOffset++] = OPC_jsr;
3506     } catch (IndexOutOfBoundsException e) {
3507       resizeByteArray(OPC_jsr);
3508     }
3509     lbl.branch();
3510   }
3511   final public void jsr_w(Label lbl) {
3512     countLabels = 0;
3513     try {
3514       position++;
3515       bCodeStream[classFileOffset++] = OPC_jsr_w;
3516     } catch (IndexOutOfBoundsException e) {
3517       resizeByteArray(OPC_jsr_w);
3518     }
3519     lbl.branchWide();
3520   }
3521   final public void l2d() {
3522     countLabels = 0;
3523     try {
3524       position++;
3525       bCodeStream[classFileOffset++] = OPC_l2d;
3526     } catch (IndexOutOfBoundsException e) {
3527       resizeByteArray(OPC_l2d);
3528     }
3529   }
3530   final public void l2f() {
3531     countLabels = 0;
3532     stackDepth--;
3533     try {
3534       position++;
3535       bCodeStream[classFileOffset++] = OPC_l2f;
3536     } catch (IndexOutOfBoundsException e) {
3537       resizeByteArray(OPC_l2f);
3538     }
3539   }
3540   final public void l2i() {
3541     countLabels = 0;
3542     stackDepth--;
3543     try {
3544       position++;
3545       bCodeStream[classFileOffset++] = OPC_l2i;
3546     } catch (IndexOutOfBoundsException e) {
3547       resizeByteArray(OPC_l2i);
3548     }
3549   }
3550   final public void ladd() {
3551     countLabels = 0;
3552     stackDepth -= 2;
3553     try {
3554       position++;
3555       bCodeStream[classFileOffset++] = OPC_ladd;
3556     } catch (IndexOutOfBoundsException e) {
3557       resizeByteArray(OPC_ladd);
3558     }
3559   }
3560   final public void laload() {
3561     countLabels = 0;
3562     try {
3563       position++;
3564       bCodeStream[classFileOffset++] = OPC_laload;
3565     } catch (IndexOutOfBoundsException e) {
3566       resizeByteArray(OPC_laload);
3567     }
3568   }
3569   final public void land() {
3570     countLabels = 0;
3571     stackDepth -= 2;
3572     try {
3573       position++;
3574       bCodeStream[classFileOffset++] = OPC_land;
3575     } catch (IndexOutOfBoundsException e) {
3576       resizeByteArray(OPC_land);
3577     }
3578   }
3579   final public void lastore() {
3580     countLabels = 0;
3581     stackDepth -= 4;
3582     try {
3583       position++;
3584       bCodeStream[classFileOffset++] = OPC_lastore;
3585     } catch (IndexOutOfBoundsException e) {
3586       resizeByteArray(OPC_lastore);
3587     }
3588   }
3589   final public void lcmp() {
3590     countLabels = 0;
3591     stackDepth -= 3;
3592     try {
3593       position++;
3594       bCodeStream[classFileOffset++] = OPC_lcmp;
3595     } catch (IndexOutOfBoundsException e) {
3596       resizeByteArray(OPC_lcmp);
3597     }
3598   }
3599   final public void lconst_0() {
3600     countLabels = 0;
3601     stackDepth += 2;
3602     if (stackDepth > stackMax)
3603       stackMax = stackDepth;
3604     try {
3605       position++;
3606       bCodeStream[classFileOffset++] = OPC_lconst_0;
3607     } catch (IndexOutOfBoundsException e) {
3608       resizeByteArray(OPC_lconst_0);
3609     }
3610   }
3611   final public void lconst_1() {
3612     countLabels = 0;
3613     stackDepth += 2;
3614     if (stackDepth > stackMax)
3615       stackMax = stackDepth;
3616     try {
3617       position++;
3618       bCodeStream[classFileOffset++] = OPC_lconst_1;
3619     } catch (IndexOutOfBoundsException e) {
3620       resizeByteArray(OPC_lconst_1);
3621     }
3622   }
3623   final public void ldc(float constant) {
3624     countLabels = 0;
3625     int index = constantPool.literalIndex(constant);
3626     stackDepth++;
3627     if (stackDepth > stackMax)
3628       stackMax = stackDepth;
3629     if (index > 255) {
3630       // Generate a ldc_w
3631       try {
3632         position++;
3633         bCodeStream[classFileOffset++] = OPC_ldc_w;
3634       } catch (IndexOutOfBoundsException e) {
3635         resizeByteArray(OPC_ldc_w);
3636       }
3637       writeUnsignedShort(index);
3638     } else {
3639       // Generate a ldc
3640       try {
3641         position++;
3642         bCodeStream[classFileOffset++] = OPC_ldc;
3643       } catch (IndexOutOfBoundsException e) {
3644         resizeByteArray(OPC_ldc);
3645       }
3646       writeUnsignedByte(index);
3647     }
3648   }
3649   final public void ldc(int constant) {
3650     countLabels = 0;
3651     int index = constantPool.literalIndex(constant);
3652     stackDepth++;
3653     if (stackDepth > stackMax)
3654       stackMax = stackDepth;
3655     if (index > 255) {
3656       // Generate a ldc_w
3657       try {
3658         position++;
3659         bCodeStream[classFileOffset++] = OPC_ldc_w;
3660       } catch (IndexOutOfBoundsException e) {
3661         resizeByteArray(OPC_ldc_w);
3662       }
3663       writeUnsignedShort(index);
3664     } else {
3665       // Generate a ldc
3666       try {
3667         position++;
3668         bCodeStream[classFileOffset++] = OPC_ldc;
3669       } catch (IndexOutOfBoundsException e) {
3670         resizeByteArray(OPC_ldc);
3671       }
3672       writeUnsignedByte(index);
3673     }
3674   }
3675   final public void ldc(String constant) {
3676     countLabels = 0;
3677     int currentConstantPoolIndex = constantPool.currentIndex;
3678     int currentConstantPoolOffset = constantPool.currentOffset;
3679     int currentCodeStreamPosition = position;
3680     int index = constantPool.literalIndexForLdc(constant.toCharArray());
3681     if (index > 0) {
3682       // the string already exists inside the constant pool
3683       // we reuse the same index
3684       stackDepth++;
3685       if (stackDepth > stackMax)
3686         stackMax = stackDepth;
3687       if (index > 255) {
3688         // Generate a ldc_w
3689         try {
3690           position++;
3691           bCodeStream[classFileOffset++] = OPC_ldc_w;
3692         } catch (IndexOutOfBoundsException e) {
3693           resizeByteArray(OPC_ldc_w);
3694         }
3695         writeUnsignedShort(index);
3696       } else {
3697         // Generate a ldc
3698         try {
3699           position++;
3700           bCodeStream[classFileOffset++] = OPC_ldc;
3701         } catch (IndexOutOfBoundsException e) {
3702           resizeByteArray(OPC_ldc);
3703         }
3704         writeUnsignedByte(index);
3705       }
3706     } else {
3707       // the string is too big to be utf8-encoded in one pass.
3708       // we have to split it into different pieces.
3709       // first we clean all side-effects due to the code above
3710       // this case is very rare, so we can afford to lose time to handle it
3711       char[] constantChars = constant.toCharArray();
3712       position = currentCodeStreamPosition;
3713       constantPool.currentIndex = currentConstantPoolIndex;
3714       constantPool.currentOffset = currentConstantPoolOffset;
3715       constantPool.stringCache.remove(constantChars);
3716       constantPool.UTF8Cache.remove(constantChars);
3717       int i = 0;
3718       int length = 0;
3719       int constantLength = constant.length();
3720       byte[] utf8encoding = new byte[Math.min(constantLength + 100, 65535)];
3721       int utf8encodingLength = 0;
3722       while ((length < 65532) && (i < constantLength)) {
3723         char current = constantChars[i];
3724         // we resize the byte array immediately if necessary
3725         if (length + 3 > (utf8encodingLength = utf8encoding.length)) {
3726           System.arraycopy(utf8encoding, 0, (utf8encoding = new byte[Math.min(utf8encodingLength + 100, 65535)]), 0, length);
3727         }
3728         if ((current >= 0x0001) && (current <= 0x007F)) {
3729           // we only need one byte: ASCII table
3730           utf8encoding[length++] = (byte) current;
3731         } else {
3732           if (current > 0x07FF) {
3733             // we need 3 bytes
3734             utf8encoding[length++] = (byte) (0xE0 | ((current >> 12) & 0x0F)); // 0xE0 = 1110 0000
3735             utf8encoding[length++] = (byte) (0x80 | ((current >> 6) & 0x3F)); // 0x80 = 1000 0000
3736             utf8encoding[length++] = (byte) (0x80 | (current & 0x3F)); // 0x80 = 1000 0000
3737           } else {
3738             // we can be 0 or between 0x0080 and 0x07FF
3739             // In that case we only need 2 bytes
3740             utf8encoding[length++] = (byte) (0xC0 | ((current >> 6) & 0x1F)); // 0xC0 = 1100 0000
3741             utf8encoding[length++] = (byte) (0x80 | (current & 0x3F)); // 0x80 = 1000 0000
3742           }
3743         }
3744         i++;
3745       }
3746       // check if all the string is encoded (PR 1PR2DWJ)
3747       // the string is too big to be encoded in one pass
3748       newStringBuffer();
3749       dup();
3750       // write the first part
3751       char[] subChars = new char[i];
3752       System.arraycopy(constantChars, 0, subChars, 0, i);
3753       System.arraycopy(utf8encoding, 0, (utf8encoding = new byte[length]), 0, length);
3754       index = constantPool.literalIndex(subChars, utf8encoding);
3755       stackDepth++;
3756       if (stackDepth > stackMax)
3757         stackMax = stackDepth;
3758       if (index > 255) {
3759         // Generate a ldc_w
3760         try {
3761           position++;
3762           bCodeStream[classFileOffset++] = OPC_ldc_w;
3763         } catch (IndexOutOfBoundsException e) {
3764           resizeByteArray(OPC_ldc_w);
3765         }
3766         writeUnsignedShort(index);
3767       } else {
3768         // Generate a ldc
3769         try {
3770           position++;
3771           bCodeStream[classFileOffset++] = OPC_ldc;
3772         } catch (IndexOutOfBoundsException e) {
3773           resizeByteArray(OPC_ldc);
3774         }
3775         writeUnsignedByte(index);
3776       }
3777       // write the remaining part
3778       invokeStringBufferStringConstructor();
3779       while (i < constantLength) {
3780         length = 0;
3781         utf8encoding = new byte[Math.min(constantLength - i + 100, 65535)];
3782         int startIndex = i;
3783         while ((length < 65532) && (i < constantLength)) {
3784           char current = constantChars[i];
3785           // we resize the byte array immediately if necessary
3786           if (constantLength + 2 > (utf8encodingLength = utf8encoding.length)) {
3787             System.arraycopy(utf8encoding, 0, (utf8encoding = new byte[Math.min(utf8encodingLength + 100, 65535)]), 0, length);
3788           }
3789           if ((current >= 0x0001) && (current <= 0x007F)) {
3790             // we only need one byte: ASCII table
3791             utf8encoding[length++] = (byte) current;
3792           } else {
3793             if (current > 0x07FF) {
3794               // we need 3 bytes
3795               utf8encoding[length++] = (byte) (0xE0 | ((current >> 12) & 0x0F)); // 0xE0 = 1110 0000
3796               utf8encoding[length++] = (byte) (0x80 | ((current >> 6) & 0x3F)); // 0x80 = 1000 0000
3797               utf8encoding[length++] = (byte) (0x80 | (current & 0x3F)); // 0x80 = 1000 0000
3798             } else {
3799               // we can be 0 or between 0x0080 and 0x07FF
3800               // In that case we only need 2 bytes
3801               utf8encoding[length++] = (byte) (0xC0 | ((current >> 6) & 0x1F)); // 0xC0 = 1100 0000
3802               utf8encoding[length++] = (byte) (0x80 | (current & 0x3F)); // 0x80 = 1000 0000
3803             }
3804           }
3805           i++;
3806         }
3807         // the next part is done
3808         subChars = new char[i - startIndex];
3809         System.arraycopy(constantChars, startIndex, subChars, 0, i - startIndex);
3810         System.arraycopy(utf8encoding, 0, (utf8encoding = new byte[length]), 0, length);
3811         index = constantPool.literalIndex(subChars, utf8encoding);
3812         stackDepth++;
3813         if (stackDepth > stackMax)
3814           stackMax = stackDepth;
3815         if (index > 255) {
3816           // Generate a ldc_w
3817           try {
3818             position++;
3819             bCodeStream[classFileOffset++] = OPC_ldc_w;
3820           } catch (IndexOutOfBoundsException e) {
3821             resizeByteArray(OPC_ldc_w);
3822           }
3823           writeUnsignedShort(index);
3824         } else {
3825           // Generate a ldc
3826           try {
3827             position++;
3828             bCodeStream[classFileOffset++] = OPC_ldc;
3829           } catch (IndexOutOfBoundsException e) {
3830             resizeByteArray(OPC_ldc);
3831           }
3832           writeUnsignedByte(index);
3833         }
3834         // now on the stack it should be a StringBuffer and a string.
3835         invokeStringBufferAppendForType(T_String);
3836       }
3837       invokeStringBufferToString();
3838       invokeStringIntern();
3839     }
3840   }
3841   final public void ldc2_w(double constant) {
3842     countLabels = 0;
3843     int index = constantPool.literalIndex(constant);
3844     stackDepth += 2;
3845     if (stackDepth > stackMax)
3846       stackMax = stackDepth;
3847     // Generate a ldc2_w
3848     try {
3849       position++;
3850       bCodeStream[classFileOffset++] = OPC_ldc2_w;
3851     } catch (IndexOutOfBoundsException e) {
3852       resizeByteArray(OPC_ldc2_w);
3853     }
3854     writeUnsignedShort(index);
3855   }
3856   final public void ldc2_w(long constant) {
3857     countLabels = 0;
3858     int index = constantPool.literalIndex(constant);
3859     stackDepth += 2;
3860     if (stackDepth > stackMax)
3861       stackMax = stackDepth;
3862     // Generate a ldc2_w
3863     try {
3864       position++;
3865       bCodeStream[classFileOffset++] = OPC_ldc2_w;
3866     } catch (IndexOutOfBoundsException e) {
3867       resizeByteArray(OPC_ldc2_w);
3868     }
3869     writeUnsignedShort(index);
3870   }
3871   final public void ldiv() {
3872     countLabels = 0;
3873     stackDepth -= 2;
3874     try {
3875       position++;
3876       bCodeStream[classFileOffset++] = OPC_ldiv;
3877     } catch (IndexOutOfBoundsException e) {
3878       resizeByteArray(OPC_ldiv);
3879     }
3880   }
3881   final public void lload(int iArg) {
3882     countLabels = 0;
3883     stackDepth += 2;
3884     if (maxLocals <= iArg + 1) {
3885       maxLocals = iArg + 2;
3886     }
3887     if (stackDepth > stackMax)
3888       stackMax = stackDepth;
3889     if (iArg > 255) { // Widen
3890       try {
3891         position++;
3892         bCodeStream[classFileOffset++] = OPC_wide;
3893       } catch (IndexOutOfBoundsException e) {
3894         resizeByteArray(OPC_wide);
3895       }
3896       try {
3897         position++;
3898         bCodeStream[classFileOffset++] = OPC_lload;
3899       } catch (IndexOutOfBoundsException e) {
3900         resizeByteArray(OPC_lload);
3901       }
3902       writeUnsignedShort(iArg);
3903     } else {
3904       try {
3905         position++;
3906         bCodeStream[classFileOffset++] = OPC_lload;
3907       } catch (IndexOutOfBoundsException e) {
3908         resizeByteArray(OPC_lload);
3909       }
3910       try {
3911         position++;
3912         bCodeStream[classFileOffset++] = (byte) iArg;
3913       } catch (IndexOutOfBoundsException e) {
3914         resizeByteArray((byte) iArg);
3915       }
3916     }
3917   }
3918   final public void lload_0() {
3919     countLabels = 0;
3920     stackDepth += 2;
3921     if (maxLocals < 2) {
3922       maxLocals = 2;
3923     }
3924     if (stackDepth > stackMax)
3925       stackMax = stackDepth;
3926     try {
3927       position++;
3928       bCodeStream[classFileOffset++] = OPC_lload_0;
3929     } catch (IndexOutOfBoundsException e) {
3930       resizeByteArray(OPC_lload_0);
3931     }
3932   }
3933   final public void lload_1() {
3934     countLabels = 0;
3935     stackDepth += 2;
3936     if (maxLocals < 3) {
3937       maxLocals = 3;
3938     }
3939     if (stackDepth > stackMax)
3940       stackMax = stackDepth;
3941     try {
3942       position++;
3943       bCodeStream[classFileOffset++] = OPC_lload_1;
3944     } catch (IndexOutOfBoundsException e) {
3945       resizeByteArray(OPC_lload_1);
3946     }
3947   }
3948   final public void lload_2() {
3949     countLabels = 0;
3950     stackDepth += 2;
3951     if (maxLocals < 4) {
3952       maxLocals = 4;
3953     }
3954     if (stackDepth > stackMax)
3955       stackMax = stackDepth;
3956     try {
3957       position++;
3958       bCodeStream[classFileOffset++] = OPC_lload_2;
3959     } catch (IndexOutOfBoundsException e) {
3960       resizeByteArray(OPC_lload_2);
3961     }
3962   }
3963   final public void lload_3() {
3964     countLabels = 0;
3965     stackDepth += 2;
3966     if (maxLocals < 5) {
3967       maxLocals = 5;
3968     }
3969     if (stackDepth > stackMax)
3970       stackMax = stackDepth;
3971     try {
3972       position++;
3973       bCodeStream[classFileOffset++] = OPC_lload_3;
3974     } catch (IndexOutOfBoundsException e) {
3975       resizeByteArray(OPC_lload_3);
3976     }
3977   }
3978   final public void lmul() {
3979     countLabels = 0;
3980     stackDepth -= 2;
3981     try {
3982       position++;
3983       bCodeStream[classFileOffset++] = OPC_lmul;
3984     } catch (IndexOutOfBoundsException e) {
3985       resizeByteArray(OPC_lmul);
3986     }
3987   }
3988   final public void lneg() {
3989     countLabels = 0;
3990     try {
3991       position++;
3992       bCodeStream[classFileOffset++] = OPC_lneg;
3993     } catch (IndexOutOfBoundsException e) {
3994       resizeByteArray(OPC_lneg);
3995     }
3996   }
3997   public final void load(LocalVariableBinding localBinding) {
3998     countLabels = 0;
3999     TypeBinding typeBinding = localBinding.type;
4000     int resolvedPosition = localBinding.resolvedPosition;
4001     // Using dedicated int bytecode
4002     if (typeBinding == IntBinding) {
4003       switch (resolvedPosition) {
4004         case 0 :
4005           this.iload_0();
4006           break;
4007         case 1 :
4008           this.iload_1();
4009           break;
4010         case 2 :
4011           this.iload_2();
4012           break;
4013         case 3 :
4014           this.iload_3();
4015           break;
4016         default :
4017           this.iload(resolvedPosition);
4018       }
4019       return;
4020     }
4021     // Using dedicated float bytecode
4022     if (typeBinding == FloatBinding) {
4023       switch (resolvedPosition) {
4024         case 0 :
4025           this.fload_0();
4026           break;
4027         case 1 :
4028           this.fload_1();
4029           break;
4030         case 2 :
4031           this.fload_2();
4032           break;
4033         case 3 :
4034           this.fload_3();
4035           break;
4036         default :
4037           this.fload(resolvedPosition);
4038       }
4039       return;
4040     }
4041     // Using dedicated long bytecode
4042     if (typeBinding == LongBinding) {
4043       switch (resolvedPosition) {
4044         case 0 :
4045           this.lload_0();
4046           break;
4047         case 1 :
4048           this.lload_1();
4049           break;
4050         case 2 :
4051           this.lload_2();
4052           break;
4053         case 3 :
4054           this.lload_3();
4055           break;
4056         default :
4057           this.lload(resolvedPosition);
4058       }
4059       return;
4060     }
4061     // Using dedicated double bytecode
4062     if (typeBinding == DoubleBinding) {
4063       switch (resolvedPosition) {
4064         case 0 :
4065           this.dload_0();
4066           break;
4067         case 1 :
4068           this.dload_1();
4069           break;
4070         case 2 :
4071           this.dload_2();
4072           break;
4073         case 3 :
4074           this.dload_3();
4075           break;
4076         default :
4077           this.dload(resolvedPosition);
4078       }
4079       return;
4080     }
4081     // boolean, byte, char and short are handled as int
4082     if ((typeBinding == ByteBinding)
4083       || (typeBinding == CharBinding)
4084       || (typeBinding == BooleanBinding)
4085       || (typeBinding == ShortBinding)) {
4086       switch (resolvedPosition) {
4087         case 0 :
4088           this.iload_0();
4089           break;
4090         case 1 :
4091           this.iload_1();
4092           break;
4093         case 2 :
4094           this.iload_2();
4095           break;
4096         case 3 :
4097           this.iload_3();
4098           break;
4099         default :
4100           this.iload(resolvedPosition);
4101       }
4102       return;
4103     }
4104
4105     // Reference object
4106     switch (resolvedPosition) {
4107       case 0 :
4108         this.aload_0();
4109         break;
4110       case 1 :
4111         this.aload_1();
4112         break;
4113       case 2 :
4114         this.aload_2();
4115         break;
4116       case 3 :
4117         this.aload_3();
4118         break;
4119       default :
4120         this.aload(resolvedPosition);
4121     }
4122   }
4123   public final void load(TypeBinding typeBinding, int resolvedPosition) {
4124     countLabels = 0;
4125     // Using dedicated int bytecode
4126     if (typeBinding == IntBinding) {
4127       switch (resolvedPosition) {
4128         case 0 :
4129           this.iload_0();
4130           break;
4131         case 1 :
4132           this.iload_1();
4133           break;
4134         case 2 :
4135           this.iload_2();
4136           break;
4137         case 3 :
4138           this.iload_3();
4139           break;
4140         default :
4141           this.iload(resolvedPosition);
4142       }
4143       return;
4144     }
4145     // Using dedicated float bytecode
4146     if (typeBinding == FloatBinding) {
4147       switch (resolvedPosition) {
4148         case 0 :
4149           this.fload_0();
4150           break;
4151         case 1 :
4152           this.fload_1();
4153           break;
4154         case 2 :
4155           this.fload_2();
4156           break;
4157         case 3 :
4158           this.fload_3();
4159           break;
4160         default :
4161           this.fload(resolvedPosition);
4162       }
4163       return;
4164     }
4165     // Using dedicated long bytecode
4166     if (typeBinding == LongBinding) {
4167       switch (resolvedPosition) {
4168         case 0 :
4169           this.lload_0();
4170           break;
4171         case 1 :
4172           this.lload_1();
4173           break;
4174         case 2 :
4175           this.lload_2();
4176           break;
4177         case 3 :
4178           this.lload_3();
4179           break;
4180         default :
4181           this.lload(resolvedPosition);
4182       }
4183       return;
4184     }
4185     // Using dedicated double bytecode
4186     if (typeBinding == DoubleBinding) {
4187       switch (resolvedPosition) {
4188         case 0 :
4189           this.dload_0();
4190           break;
4191         case 1 :
4192           this.dload_1();
4193           break;
4194         case 2 :
4195           this.dload_2();
4196           break;
4197         case 3 :
4198           this.dload_3();
4199           break;
4200         default :
4201           this.dload(resolvedPosition);
4202       }
4203       return;
4204     }
4205     // boolean, byte, char and short are handled as int
4206     if ((typeBinding == ByteBinding)
4207       || (typeBinding == CharBinding)
4208       || (typeBinding == BooleanBinding)
4209       || (typeBinding == ShortBinding)) {
4210       switch (resolvedPosition) {
4211         case 0 :
4212           this.iload_0();
4213           break;
4214         case 1 :
4215           this.iload_1();
4216           break;
4217         case 2 :
4218           this.iload_2();
4219           break;
4220         case 3 :
4221           this.iload_3();
4222           break;
4223         default :
4224           this.iload(resolvedPosition);
4225       }
4226       return;
4227     }
4228
4229     // Reference object
4230     switch (resolvedPosition) {
4231       case 0 :
4232         this.aload_0();
4233         break;
4234       case 1 :
4235         this.aload_1();
4236         break;
4237       case 2 :
4238         this.aload_2();
4239         break;
4240       case 3 :
4241         this.aload_3();
4242         break;
4243       default :
4244         this.aload(resolvedPosition);
4245     }
4246   }
4247   public final void loadInt(int resolvedPosition) {
4248     // Using dedicated int bytecode
4249     switch (resolvedPosition) {
4250       case 0 :
4251         this.iload_0();
4252         break;
4253       case 1 :
4254         this.iload_1();
4255         break;
4256       case 2 :
4257         this.iload_2();
4258         break;
4259       case 3 :
4260         this.iload_3();
4261         break;
4262       default :
4263         this.iload(resolvedPosition);
4264     }
4265   }
4266   public final void loadObject(int resolvedPosition) {
4267     switch (resolvedPosition) {
4268       case 0 :
4269         this.aload_0();
4270         break;
4271       case 1 :
4272         this.aload_1();
4273         break;
4274       case 2 :
4275         this.aload_2();
4276         break;
4277       case 3 :
4278         this.aload_3();
4279         break;
4280       default :
4281         this.aload(resolvedPosition);
4282     }
4283   }
4284   final public void lookupswitch(CaseLabel defaultLabel, int[] keys, int[] sortedIndexes, CaseLabel[] casesLabel) {
4285     countLabels = 0;
4286     stackDepth--;
4287     int length = keys.length;
4288     int pos = position;
4289     defaultLabel.placeInstruction();
4290     for (int i = 0; i < length; i++) {
4291       casesLabel[i].placeInstruction();
4292     }
4293     try {
4294       position++;
4295       bCodeStream[classFileOffset++] = OPC_lookupswitch;
4296     } catch (IndexOutOfBoundsException e) {
4297       resizeByteArray(OPC_lookupswitch);
4298     }
4299     for (int i = (3 - (pos % 4)); i > 0; i--) {
4300       position++; // Padding
4301       classFileOffset++;
4302     }
4303     defaultLabel.branch();
4304     writeSignedWord(length);
4305     for (int i = 0; i < length; i++) {
4306       writeSignedWord(keys[sortedIndexes[i]]);
4307       casesLabel[sortedIndexes[i]].branch();
4308     }
4309   }
4310   final public void lor() {
4311     countLabels = 0;
4312     stackDepth -= 2;
4313     try {
4314       position++;
4315       bCodeStream[classFileOffset++] = OPC_lor;
4316     } catch (IndexOutOfBoundsException e) {
4317       resizeByteArray(OPC_lor);
4318     }
4319   }
4320   final public void lrem() {
4321     countLabels = 0;
4322     stackDepth -= 2;
4323     try {
4324       position++;
4325       bCodeStream[classFileOffset++] = OPC_lrem;
4326     } catch (IndexOutOfBoundsException e) {
4327       resizeByteArray(OPC_lrem);
4328     }
4329   }
4330   final public void lreturn() {
4331     countLabels = 0;
4332     stackDepth -= 2;
4333     // the stackDepth should be equal to 0
4334     try {
4335       position++;
4336       bCodeStream[classFileOffset++] = OPC_lreturn;
4337     } catch (IndexOutOfBoundsException e) {
4338       resizeByteArray(OPC_lreturn);
4339     }
4340   }
4341   final public void lshl() {
4342     countLabels = 0;
4343     stackDepth--;
4344     try {
4345       position++;
4346       bCodeStream[classFileOffset++] = OPC_lshl;
4347     } catch (IndexOutOfBoundsException e) {
4348       resizeByteArray(OPC_lshl);
4349     }
4350   }
4351   final public void lshr() {
4352     countLabels = 0;
4353     stackDepth--;
4354     try {
4355       position++;
4356       bCodeStream[classFileOffset++] = OPC_lshr;
4357     } catch (IndexOutOfBoundsException e) {
4358       resizeByteArray(OPC_lshr);
4359     }
4360   }
4361   final public void lstore(int iArg) {
4362     countLabels = 0;
4363     stackDepth -= 2;
4364     if (maxLocals <= iArg + 1) {
4365       maxLocals = iArg + 2;
4366     }
4367     if (iArg > 255) { // Widen
4368       try {
4369         position++;
4370         bCodeStream[classFileOffset++] = OPC_wide;
4371       } catch (IndexOutOfBoundsException e) {
4372         resizeByteArray(OPC_wide);
4373       }
4374       try {
4375         position++;
4376         bCodeStream[classFileOffset++] = OPC_lstore;
4377       } catch (IndexOutOfBoundsException e) {
4378         resizeByteArray(OPC_lstore);
4379       }
4380       writeUnsignedShort(iArg);
4381     } else {
4382       try {
4383         position++;
4384         bCodeStream[classFileOffset++] = OPC_lstore;
4385       } catch (IndexOutOfBoundsException e) {
4386         resizeByteArray(OPC_lstore);
4387       }
4388       try {
4389         position++;
4390         bCodeStream[classFileOffset++] = (byte) iArg;
4391       } catch (IndexOutOfBoundsException e) {
4392         resizeByteArray((byte) iArg);
4393       }
4394     }
4395   }
4396   final public void lstore_0() {
4397     countLabels = 0;
4398     stackDepth -= 2;
4399     if (maxLocals < 2) {
4400       maxLocals = 2;
4401     }
4402     try {
4403       position++;
4404       bCodeStream[classFileOffset++] = OPC_lstore_0;
4405     } catch (IndexOutOfBoundsException e) {
4406       resizeByteArray(OPC_lstore_0);
4407     }
4408   }
4409   final public void lstore_1() {
4410     countLabels = 0;
4411     stackDepth -= 2;
4412     if (maxLocals < 3) {
4413       maxLocals = 3;
4414     }
4415     try {
4416       position++;
4417       bCodeStream[classFileOffset++] = OPC_lstore_1;
4418     } catch (IndexOutOfBoundsException e) {
4419       resizeByteArray(OPC_lstore_1);
4420     }
4421   }
4422   final public void lstore_2() {
4423     countLabels = 0;
4424     stackDepth -= 2;
4425     if (maxLocals < 4) {
4426       maxLocals = 4;
4427     }
4428     try {
4429       position++;
4430       bCodeStream[classFileOffset++] = OPC_lstore_2;
4431     } catch (IndexOutOfBoundsException e) {
4432       resizeByteArray(OPC_lstore_2);
4433     }
4434   }
4435   final public void lstore_3() {
4436     countLabels = 0;
4437     stackDepth -= 2;
4438     if (maxLocals < 5) {
4439       maxLocals = 5;
4440     }
4441     try {
4442       position++;
4443       bCodeStream[classFileOffset++] = OPC_lstore_3;
4444     } catch (IndexOutOfBoundsException e) {
4445       resizeByteArray(OPC_lstore_3);
4446     }
4447   }
4448   final public void lsub() {
4449     countLabels = 0;
4450     stackDepth -= 2;
4451     try {
4452       position++;
4453       bCodeStream[classFileOffset++] = OPC_lsub;
4454     } catch (IndexOutOfBoundsException e) {
4455       resizeByteArray(OPC_lsub);
4456     }
4457   }
4458   final public void lushr() {
4459     countLabels = 0;
4460     stackDepth--;
4461     try {
4462       position++;
4463       bCodeStream[classFileOffset++] = OPC_lushr;
4464     } catch (IndexOutOfBoundsException e) {
4465       resizeByteArray(OPC_lushr);
4466     }
4467   }
4468   final public void lxor() {
4469     countLabels = 0;
4470     stackDepth -= 2;
4471     try {
4472       position++;
4473       bCodeStream[classFileOffset++] = OPC_lxor;
4474     } catch (IndexOutOfBoundsException e) {
4475       resizeByteArray(OPC_lxor);
4476     }
4477   }
4478   final public void monitorenter() {
4479     countLabels = 0;
4480     stackDepth--;
4481     try {
4482       position++;
4483       bCodeStream[classFileOffset++] = OPC_monitorenter;
4484     } catch (IndexOutOfBoundsException e) {
4485       resizeByteArray(OPC_monitorenter);
4486     }
4487   }
4488   final public void monitorexit() {
4489     countLabels = 0;
4490     stackDepth--;
4491     try {
4492       position++;
4493       bCodeStream[classFileOffset++] = OPC_monitorexit;
4494     } catch (IndexOutOfBoundsException e) {
4495       resizeByteArray(OPC_monitorexit);
4496     }
4497   }
4498   final public void multianewarray(TypeBinding typeBinding, int dimensions) {
4499     countLabels = 0;
4500     stackDepth += (1 - dimensions);
4501     try {
4502       position++;
4503       bCodeStream[classFileOffset++] = OPC_multianewarray;
4504     } catch (IndexOutOfBoundsException e) {
4505       resizeByteArray(OPC_multianewarray);
4506     }
4507     writeUnsignedShort(constantPool.literalIndex(typeBinding));
4508     writeUnsignedByte(dimensions);
4509   }
4510   public static void needImplementation() {
4511   }
4512   /**
4513    * We didn't call it new, because there is a conflit with the new keyword
4514    */
4515   final public void new_(TypeBinding typeBinding) {
4516     countLabels = 0;
4517     stackDepth++;
4518     if (stackDepth > stackMax)
4519       stackMax = stackDepth;
4520     try {
4521       position++;
4522       bCodeStream[classFileOffset++] = OPC_new;
4523     } catch (IndexOutOfBoundsException e) {
4524       resizeByteArray(OPC_new);
4525     }
4526     writeUnsignedShort(constantPool.literalIndex(typeBinding));
4527   }
4528   final public void newarray(int array_Type) {
4529     countLabels = 0;
4530     try {
4531       position++;
4532       bCodeStream[classFileOffset++] = OPC_newarray;
4533     } catch (IndexOutOfBoundsException e) {
4534       resizeByteArray(OPC_newarray);
4535     }
4536     writeUnsignedByte(array_Type);
4537   }
4538   public void newArray(Scope scope, ArrayBinding arrayBinding) {
4539     TypeBinding component = arrayBinding.elementsType(scope);
4540     switch (component.id) {
4541       case T_int :
4542         this.newarray(10);
4543         break;
4544       case T_byte :
4545         this.newarray(8);
4546         break;
4547       case T_boolean :
4548         this.newarray(4);
4549         break;
4550       case T_short :
4551         this.newarray(9);
4552         break;
4553       case T_char :
4554         this.newarray(5);
4555         break;
4556       case T_long :
4557         this.newarray(11);
4558         break;
4559       case T_float :
4560         this.newarray(6);
4561         break;
4562       case T_double :
4563         this.newarray(7);
4564         break;
4565       default :
4566         this.anewarray(component);
4567     }
4568   }
4569   public void newJavaLangError() {
4570     // new: java.lang.Error
4571     countLabels = 0;
4572     stackDepth++;
4573     if (stackDepth > stackMax)
4574       stackMax = stackDepth;
4575     try {
4576       position++;
4577       bCodeStream[classFileOffset++] = OPC_new;
4578     } catch (IndexOutOfBoundsException e) {
4579       resizeByteArray(OPC_new);
4580     }
4581     writeUnsignedShort(constantPool.literalIndexForJavaLangError());
4582   }
4583
4584   public void newJavaLangAssertionError() {
4585     // new: java.lang.AssertionError
4586     countLabels = 0;
4587     stackDepth++;
4588     if (stackDepth > stackMax)
4589       stackMax = stackDepth;
4590     try {
4591       position++;
4592       bCodeStream[classFileOffset++] = OPC_new;
4593     } catch (IndexOutOfBoundsException e) {
4594       resizeByteArray(OPC_new);
4595     }
4596     writeUnsignedShort(constantPool.literalIndexForJavaLangAssertionError());
4597   }
4598
4599   public void newNoClassDefFoundError() { // new: java.lang.NoClassDefFoundError
4600     countLabels = 0;
4601     stackDepth++;
4602     if (stackDepth > stackMax)
4603       stackMax = stackDepth;
4604     try {
4605       position++;
4606       bCodeStream[classFileOffset++] = OPC_new;
4607     } catch (IndexOutOfBoundsException e) {
4608       resizeByteArray(OPC_new);
4609     }
4610     writeUnsignedShort(constantPool.literalIndexForJavaLangNoClassDefFoundError());
4611   }
4612   public void newStringBuffer() { // new: java.lang.StringBuffer
4613     countLabels = 0;
4614     stackDepth++;
4615     if (stackDepth > stackMax)
4616       stackMax = stackDepth;
4617     try {
4618       position++;
4619       bCodeStream[classFileOffset++] = OPC_new;
4620     } catch (IndexOutOfBoundsException e) {
4621       resizeByteArray(OPC_new);
4622     }
4623     writeUnsignedShort(constantPool.literalIndexForJavaLangStringBuffer());
4624   }
4625   public void newWrapperFor(int typeID) {
4626     countLabels = 0;
4627     stackDepth++;
4628     if (stackDepth > stackMax)
4629       stackMax = stackDepth;
4630     try {
4631       position++;
4632       bCodeStream[classFileOffset++] = OPC_new;
4633     } catch (IndexOutOfBoundsException e) {
4634       resizeByteArray(OPC_new);
4635     }
4636     switch (typeID) {
4637       case T_int : // new: java.lang.Integer
4638         writeUnsignedShort(constantPool.literalIndexForJavaLangInteger());
4639         break;
4640       case T_boolean : // new: java.lang.Boolean
4641         writeUnsignedShort(constantPool.literalIndexForJavaLangBoolean());
4642         break;
4643       case T_byte : // new: java.lang.Byte
4644         writeUnsignedShort(constantPool.literalIndexForJavaLangByte());
4645         break;
4646       case T_char : // new: java.lang.Character
4647         writeUnsignedShort(constantPool.literalIndexForJavaLangCharacter());
4648         break;
4649       case T_float : // new: java.lang.Float
4650         writeUnsignedShort(constantPool.literalIndexForJavaLangFloat());
4651         break;
4652       case T_double : // new: java.lang.Double
4653         writeUnsignedShort(constantPool.literalIndexForJavaLangDouble());
4654         break;
4655       case T_short : // new: java.lang.Short
4656         writeUnsignedShort(constantPool.literalIndexForJavaLangShort());
4657         break;
4658       case T_long : // new: java.lang.Long
4659         writeUnsignedShort(constantPool.literalIndexForJavaLangLong());
4660         break;
4661       case T_void : // new: java.lang.Void
4662         writeUnsignedShort(constantPool.literalIndexForJavaLangVoid());
4663     }
4664   }
4665   final public void nop() {
4666     countLabels = 0;
4667     try {
4668       position++;
4669       bCodeStream[classFileOffset++] = OPC_nop;
4670     } catch (IndexOutOfBoundsException e) {
4671       resizeByteArray(OPC_nop);
4672     }
4673   }
4674   final public void pop() {
4675     countLabels = 0;
4676     stackDepth--;
4677     try {
4678       position++;
4679       bCodeStream[classFileOffset++] = OPC_pop;
4680     } catch (IndexOutOfBoundsException e) {
4681       resizeByteArray(OPC_pop);
4682     }
4683   }
4684   final public void pop2() {
4685     countLabels = 0;
4686     stackDepth -= 2;
4687     try {
4688       position++;
4689       bCodeStream[classFileOffset++] = OPC_pop2;
4690     } catch (IndexOutOfBoundsException e) {
4691       resizeByteArray(OPC_pop2);
4692     }
4693   }
4694   final public void putfield(FieldBinding fieldBinding) {
4695     countLabels = 0;
4696     int id;
4697     if (((id = fieldBinding.type.id) == T_double) || (id == T_long))
4698       stackDepth -= 3;
4699     else
4700       stackDepth -= 2;
4701     if (stackDepth > stackMax)
4702       stackMax = stackDepth;
4703     try {
4704       position++;
4705       bCodeStream[classFileOffset++] = OPC_putfield;
4706     } catch (IndexOutOfBoundsException e) {
4707       resizeByteArray(OPC_putfield);
4708     }
4709     writeUnsignedShort(constantPool.literalIndex(fieldBinding));
4710   }
4711   final public void putstatic(FieldBinding fieldBinding) {
4712     countLabels = 0;
4713     int id;
4714     if (((id = fieldBinding.type.id) == T_double) || (id == T_long))
4715       stackDepth -= 2;
4716     else
4717       stackDepth -= 1;
4718     if (stackDepth > stackMax)
4719       stackMax = stackDepth;
4720     try {
4721       position++;
4722       bCodeStream[classFileOffset++] = OPC_putstatic;
4723     } catch (IndexOutOfBoundsException e) {
4724       resizeByteArray(OPC_putstatic);
4725     }
4726     writeUnsignedShort(constantPool.literalIndex(fieldBinding));
4727   }
4728   public void record(LocalVariableBinding local) {
4729     if (!generateLocalVariableTableAttributes)
4730       return;
4731     if (allLocalsCounter == locals.length) {
4732       // resize the collection
4733       System.arraycopy(locals, 0, (locals = new LocalVariableBinding[allLocalsCounter + LOCALS_INCREMENT]), 0, allLocalsCounter);
4734     }
4735     locals[allLocalsCounter++] = local;
4736     local.initializationPCs = new int[4];
4737     local.initializationCount = 0;
4738   }
4739   public void recordPositionsFrom(int startPC, int sourcePos) {
4740
4741     /* Record positions in the table, only if nothing has
4742      * already been recorded. Since we output them on the way
4743      * up (children first for more specific info)
4744      * The pcToSourceMap table is always sorted.
4745      */
4746
4747     if (!generateLineNumberAttributes)
4748       return;
4749     if (sourcePos == 0)
4750       return;
4751
4752     // no code generated for this node. e.g. field without any initialization
4753     if (position == startPC)
4754       return;
4755
4756     // Widening an existing entry that already has the same source positions
4757     if (pcToSourceMapSize + 4 > pcToSourceMap.length) {
4758       // resize the array pcToSourceMap
4759       System.arraycopy(pcToSourceMap, 0, (pcToSourceMap = new int[pcToSourceMapSize << 1]), 0, pcToSourceMapSize);
4760     }
4761     int newLine = ClassFile.searchLineNumber(lineSeparatorPositions, sourcePos);
4762     // lastEntryPC represents the endPC of the lastEntry.
4763     if (pcToSourceMapSize > 0) {
4764       // in this case there is already an entry in the table
4765       if (pcToSourceMap[pcToSourceMapSize - 1] != newLine) {
4766         if (startPC < lastEntryPC) {
4767           // we forgot to add an entry.
4768           // search if an existing entry exists for startPC
4769           int insertionIndex = insertionIndex(pcToSourceMap, pcToSourceMapSize, startPC);
4770           if (insertionIndex != -1) {
4771             // there is no existing entry starting with startPC.
4772             int existingEntryIndex = indexOfSameLineEntrySincePC(startPC, newLine); // index for PC
4773             /* the existingEntryIndex corresponds to en entry with the same line and a PC >= startPC.
4774                 in this case it is relevant to widen this entry instead of creating a new one.
4775                 line1: this(a,
4776                   b,
4777                   c);
4778                 with this code we generate each argument. We generate a aload0 to invoke the constructor. There is no entry for this
4779                 aload0 bytecode. The first entry is the one for the argument a.
4780                 But we want the constructor call to start at the aload0 pc and not just at the pc of the first argument.
4781                 So we widen the existing entry (if there is one) or we create a new entry with the startPC.
4782             */
4783             if (existingEntryIndex != -1) {
4784               // widen existing entry
4785               pcToSourceMap[existingEntryIndex] = startPC;
4786             } else {
4787               // we have to add an entry that won't be sorted. So we sort the pcToSourceMap.
4788               System.arraycopy(
4789                 pcToSourceMap,
4790                 insertionIndex,
4791                 pcToSourceMap,
4792                 insertionIndex + 2,
4793                 pcToSourceMapSize - insertionIndex);
4794               pcToSourceMap[insertionIndex++] = startPC;
4795               pcToSourceMap[insertionIndex] = newLine;
4796               pcToSourceMapSize += 2;
4797             }
4798           }
4799           if (position != lastEntryPC) { // no bytecode since last entry pc
4800             pcToSourceMap[pcToSourceMapSize++] = lastEntryPC;
4801             pcToSourceMap[pcToSourceMapSize++] = newLine;
4802           }
4803         } else {
4804           // we can safely add the new entry. The endPC of the previous entry is not in conflit with the startPC of the new entry.
4805           pcToSourceMap[pcToSourceMapSize++] = startPC;
4806           pcToSourceMap[pcToSourceMapSize++] = newLine;
4807         }
4808       } else {
4809         /* the last recorded entry is on the same line. But it could be relevant to widen this entry.
4810            we want to extend this entry forward in case we generated some bytecode before the last entry that are not related to any statement
4811         */
4812         if (startPC < pcToSourceMap[pcToSourceMapSize - 2]) {
4813           int insertionIndex = insertionIndex(pcToSourceMap, pcToSourceMapSize, startPC);
4814           if (insertionIndex != -1) {
4815             // widen the existing entry
4816             // we have to figure out if we need to move the last entry at another location to keep a sorted table
4817             if ((pcToSourceMapSize > 4) && (pcToSourceMap[pcToSourceMapSize - 4] > startPC)) {
4818               System.arraycopy(
4819                 pcToSourceMap,
4820                 insertionIndex,
4821                 pcToSourceMap,
4822                 insertionIndex + 2,
4823                 pcToSourceMapSize - 2 - insertionIndex);
4824               pcToSourceMap[insertionIndex++] = startPC;
4825               pcToSourceMap[insertionIndex] = newLine;
4826             } else {
4827               pcToSourceMap[pcToSourceMapSize - 2] = startPC;
4828             }
4829           }
4830         }
4831       }
4832       lastEntryPC = position;
4833     } else {
4834       // record the first entry
4835       pcToSourceMap[pcToSourceMapSize++] = startPC;
4836       pcToSourceMap[pcToSourceMapSize++] = newLine;
4837       lastEntryPC = position;
4838     }
4839   }
4840   /**
4841    * @param anExceptionLabel org.eclipse.jdt.internal.compiler.codegen.ExceptionLabel
4842    */
4843   public void registerExceptionHandler(ExceptionLabel anExceptionLabel) {
4844     int length;
4845     if (exceptionHandlersNumber >= (length = exceptionHandlers.length)) {
4846       // resize the exception handlers table
4847       System.arraycopy(exceptionHandlers, 0, exceptionHandlers = new ExceptionLabel[length + LABELS_INCREMENT], 0, length);
4848     }
4849     // no need to resize. So just add the new exception label
4850     exceptionHandlers[exceptionHandlersNumber++] = anExceptionLabel;
4851   }
4852   public final void removeNotDefinitelyAssignedVariables(Scope scope, int initStateIndex) {
4853     // given some flow info, make sure we did not loose some variables initialization
4854     // if this happens, then we must update their pc entries to reflect it in debug attributes
4855     if (!generateLocalVariableTableAttributes)
4856       return;
4857     /*  if (initStateIndex == lastInitStateIndexWhenRemovingInits)
4858                 return;
4859
4860         lastInitStateIndexWhenRemovingInits = initStateIndex;
4861         if (lastInitStateIndexWhenAddingInits != initStateIndex){
4862                 lastInitStateIndexWhenAddingInits = -2;// reinitialize add index
4863                 // add(1)-remove(1)-add(1) -> ignore second add
4864                 // add(1)-remove(2)-add(1) -> perform second add
4865         }*/
4866     for (int i = 0; i < visibleLocalsCount; i++) {
4867       LocalVariableBinding localBinding = visibleLocals[i];
4868       if (localBinding != null) {
4869         if (initStateIndex == -1 || !isDefinitelyAssigned(scope, initStateIndex, localBinding)) {
4870           if (localBinding.initializationCount > 0) {
4871             localBinding.recordInitializationEndPC(position);
4872           }
4873         }
4874       }
4875     }
4876   }
4877   /**
4878    * @param methodDeclaration org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration
4879    * @param classFile org.eclipse.jdt.internal.compiler.codegen.ClassFile
4880    */
4881   public void reset(AbstractMethodDeclaration methodDeclaration, ClassFile classFile) {
4882     init(classFile);
4883     this.methodDeclaration = methodDeclaration;
4884     preserveUnusedLocals = methodDeclaration.scope.problemReporter().options.preserveAllLocalVariables;
4885     initializeMaxLocals(methodDeclaration.binding);
4886   }
4887   /**
4888    * @param methodDeclaration org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration
4889    * @param classFile org.eclipse.jdt.internal.compiler.codegen.ClassFile
4890    */
4891   public void resetForProblemClinit(ClassFile classFile) {
4892     init(classFile);
4893     maxLocals = 0;
4894   }
4895   protected final void resizeByteArray() {
4896     int actualLength = bCodeStream.length;
4897     int requiredSize = actualLength + growFactor;
4898     if (classFileOffset > requiredSize) {
4899       requiredSize = classFileOffset + growFactor;
4900     }
4901     System.arraycopy(bCodeStream, 0, (bCodeStream = new byte[requiredSize]), 0, actualLength);
4902   }
4903   /**
4904    * This method is used to resize the internal byte array in
4905    * case of a ArrayOutOfBoundsException when adding the value b.
4906    * Resize and add the new byte b inside the array.
4907    * @param b byte
4908    */
4909   protected final void resizeByteArray(byte b) {
4910     resizeByteArray();
4911     bCodeStream[classFileOffset - 1] = b;
4912   }
4913   final public void ret(int index) {
4914     countLabels = 0;
4915     if (index > 255) { // Widen
4916       try {
4917         position++;
4918         bCodeStream[classFileOffset++] = OPC_wide;
4919       } catch (IndexOutOfBoundsException e) {
4920         resizeByteArray(OPC_wide);
4921       }
4922       try {
4923         position++;
4924         bCodeStream[classFileOffset++] = OPC_ret;
4925       } catch (IndexOutOfBoundsException e) {
4926         resizeByteArray(OPC_ret);
4927       }
4928       writeUnsignedShort(index);
4929     } else { // Don't Widen
4930       try {
4931         position++;
4932         bCodeStream[classFileOffset++] = OPC_ret;
4933       } catch (IndexOutOfBoundsException e) {
4934         resizeByteArray(OPC_ret);
4935       }
4936       try {
4937         position++;
4938         bCodeStream[classFileOffset++] = (byte) index;
4939       } catch (IndexOutOfBoundsException e) {
4940         resizeByteArray((byte) index);
4941       }
4942     }
4943   }
4944   final public void return_() {
4945     countLabels = 0;
4946     // the stackDepth should be equal to 0
4947     try {
4948       position++;
4949       bCodeStream[classFileOffset++] = OPC_return;
4950     } catch (IndexOutOfBoundsException e) {
4951       resizeByteArray(OPC_return);
4952     }
4953   }
4954   final public void saload() {
4955     countLabels = 0;
4956     stackDepth--;
4957     try {
4958       position++;
4959       bCodeStream[classFileOffset++] = OPC_saload;
4960     } catch (IndexOutOfBoundsException e) {
4961       resizeByteArray(OPC_saload);
4962     }
4963   }
4964   final public void sastore() {
4965     countLabels = 0;
4966     stackDepth -= 3;
4967     try {
4968       position++;
4969       bCodeStream[classFileOffset++] = OPC_sastore;
4970     } catch (IndexOutOfBoundsException e) {
4971       resizeByteArray(OPC_sastore);
4972     }
4973   }
4974   /**
4975    * @param operatorConstant int
4976    * @param type_ID int
4977    */
4978   public void sendOperator(int operatorConstant, int type_ID) {
4979     switch (type_ID) {
4980       case T_int :
4981       case T_boolean :
4982       case T_char :
4983       case T_byte :
4984       case T_short :
4985         switch (operatorConstant) {
4986           case PLUS :
4987             this.iadd();
4988             break;
4989           case MINUS :
4990             this.isub();
4991             break;
4992           case MULTIPLY :
4993             this.imul();
4994             break;
4995           case DIVIDE :
4996             this.idiv();
4997             break;
4998           case REMAINDER :
4999             this.irem();
5000             break;
5001           case LEFT_SHIFT :
5002             this.ishl();
5003             break;
5004           case RIGHT_SHIFT :
5005             this.ishr();
5006             break;
5007           case UNSIGNED_RIGHT_SHIFT :
5008             this.iushr();
5009             break;
5010           case AND :
5011             this.iand();
5012             break;
5013           case OR :
5014             this.ior();
5015             break;
5016           case XOR :
5017             this.ixor();
5018             break;
5019         }
5020         break;
5021       case T_long :
5022         switch (operatorConstant) {
5023           case PLUS :
5024             this.ladd();
5025             break;
5026           case MINUS :
5027             this.lsub();
5028             break;
5029           case MULTIPLY :
5030             this.lmul();
5031             break;
5032           case DIVIDE :
5033             this.ldiv();
5034             break;
5035           case REMAINDER :
5036             this.lrem();
5037             break;
5038           case LEFT_SHIFT :
5039             this.lshl();
5040             break;
5041           case RIGHT_SHIFT :
5042             this.lshr();
5043             break;
5044           case UNSIGNED_RIGHT_SHIFT :
5045             this.lushr();
5046             break;
5047           case AND :
5048             this.land();
5049             break;
5050           case OR :
5051             this.lor();
5052             break;
5053           case XOR :
5054             this.lxor();
5055             break;
5056         }
5057         break;
5058       case T_float :
5059         switch (operatorConstant) {
5060           case PLUS :
5061             this.fadd();
5062             break;
5063           case MINUS :
5064             this.fsub();
5065             break;
5066           case MULTIPLY :
5067             this.fmul();
5068             break;
5069           case DIVIDE :
5070             this.fdiv();
5071             break;
5072           case REMAINDER :
5073             this.frem();
5074         }
5075         break;
5076       case T_double :
5077         switch (operatorConstant) {
5078           case PLUS :
5079             this.dadd();
5080             break;
5081           case MINUS :
5082             this.dsub();
5083             break;
5084           case MULTIPLY :
5085             this.dmul();
5086             break;
5087           case DIVIDE :
5088             this.ddiv();
5089             break;
5090           case REMAINDER :
5091             this.drem();
5092         }
5093     }
5094   }
5095   final public void sipush(int s) {
5096     countLabels = 0;
5097     stackDepth++;
5098     if (stackDepth > stackMax)
5099       stackMax = stackDepth;
5100     try {
5101       position++;
5102       bCodeStream[classFileOffset++] = OPC_sipush;
5103     } catch (IndexOutOfBoundsException e) {
5104       resizeByteArray(OPC_sipush);
5105     }
5106     writeSignedShort(s);
5107   }
5108   public static final void sort(int[] tab, int lo0, int hi0, int[] result) {
5109     int lo = lo0;
5110     int hi = hi0;
5111     int mid;
5112     if (hi0 > lo0) {
5113       /* Arbitrarily establishing partition element as the midpoint of
5114         * the array.
5115         */
5116       mid = tab[(lo0 + hi0) / 2];
5117       // loop through the array until indices cross
5118       while (lo <= hi) {
5119         /* find the first element that is greater than or equal to
5120          * the partition element starting from the left Index.
5121          */
5122         while ((lo < hi0) && (tab[lo] < mid))
5123           ++lo;
5124         /* find an element that is smaller than or equal to
5125          * the partition element starting from the right Index.
5126          */
5127         while ((hi > lo0) && (tab[hi] > mid))
5128           --hi;
5129         // if the indexes have not crossed, swap
5130         if (lo <= hi) {
5131           swap(tab, lo, hi, result);
5132           ++lo;
5133           --hi;
5134         }
5135       }
5136       /* If the right index has not reached the left side of array
5137         * must now sort the left partition.
5138         */
5139       if (lo0 < hi)
5140         sort(tab, lo0, hi, result);
5141       /* If the left index has not reached the right side of array
5142         * must now sort the right partition.
5143         */
5144       if (lo < hi0)
5145         sort(tab, lo, hi0, result);
5146     }
5147   }
5148   public final void store(LocalVariableBinding localBinding, boolean valueRequired) {
5149     TypeBinding type = localBinding.type;
5150     int position = localBinding.resolvedPosition;
5151     // Using dedicated int bytecode
5152     if ((type == IntBinding)
5153       || (type == CharBinding)
5154       || (type == ByteBinding)
5155       || (type == ShortBinding)
5156       || (type == BooleanBinding)) {
5157       if (valueRequired)
5158         this.dup();
5159       switch (position) {
5160         case 0 :
5161           this.istore_0();
5162           break;
5163         case 1 :
5164           this.istore_1();
5165           break;
5166         case 2 :
5167           this.istore_2();
5168           break;
5169         case 3 :
5170           this.istore_3();
5171           break;
5172         default :
5173           this.istore(position);
5174       }
5175       return;
5176     }
5177     // Using dedicated float bytecode
5178     if (type == FloatBinding) {
5179       if (valueRequired)
5180         this.dup();
5181       switch (position) {
5182         case 0 :
5183           this.fstore_0();
5184           break;
5185         case 1 :
5186           this.fstore_1();
5187           break;
5188         case 2 :
5189           this.fstore_2();
5190           break;
5191         case 3 :
5192           this.fstore_3();
5193           break;
5194         default :
5195           this.fstore(position);
5196       }
5197       return;
5198     }
5199     // Using dedicated long bytecode
5200     if (type == LongBinding) {
5201       if (valueRequired)
5202         this.dup2();
5203       switch (position) {
5204         case 0 :
5205           this.lstore_0();
5206           break;
5207         case 1 :
5208           this.lstore_1();
5209           break;
5210         case 2 :
5211           this.lstore_2();
5212           break;
5213         case 3 :
5214           this.lstore_3();
5215           break;
5216         default :
5217           this.lstore(position);
5218       }
5219       return;
5220     }
5221     // Using dedicated double bytecode
5222     if (type == DoubleBinding) {
5223       if (valueRequired)
5224         this.dup2();
5225       switch (position) {
5226         case 0 :
5227           this.dstore_0();
5228           break;
5229         case 1 :
5230           this.dstore_1();
5231           break;
5232         case 2 :
5233           this.dstore_2();
5234           break;
5235         case 3 :
5236           this.dstore_3();
5237           break;
5238         default :
5239           this.dstore(position);
5240       }
5241       return;
5242     }
5243     // Reference object
5244     if (valueRequired)
5245       this.dup();
5246     switch (position) {
5247       case 0 :
5248         this.astore_0();
5249         break;
5250       case 1 :
5251         this.astore_1();
5252         break;
5253       case 2 :
5254         this.astore_2();
5255         break;
5256       case 3 :
5257         this.astore_3();
5258         break;
5259       default :
5260         this.astore(position);
5261     }
5262   }
5263   public final void store(TypeBinding type, int position) {
5264     // Using dedicated int bytecode
5265     if ((type == IntBinding)
5266       || (type == CharBinding)
5267       || (type == ByteBinding)
5268       || (type == ShortBinding)
5269       || (type == BooleanBinding)) {
5270       switch (position) {
5271         case 0 :
5272           this.istore_0();
5273           break;
5274         case 1 :
5275           this.istore_1();
5276           break;
5277         case 2 :
5278           this.istore_2();
5279           break;
5280         case 3 :
5281           this.istore_3();
5282           break;
5283         default :
5284           this.istore(position);
5285       }
5286       return;
5287     }
5288     // Using dedicated float bytecode
5289     if (type == FloatBinding) {
5290       switch (position) {
5291         case 0 :
5292           this.fstore_0();
5293           break;
5294         case 1 :
5295           this.fstore_1();
5296           break;
5297         case 2 :
5298           this.fstore_2();
5299           break;
5300         case 3 :
5301           this.fstore_3();
5302           break;
5303         default :
5304           this.fstore(position);
5305       }
5306       return;
5307     }
5308     // Using dedicated long bytecode
5309     if (type == LongBinding) {
5310       switch (position) {
5311         case 0 :
5312           this.lstore_0();
5313           break;
5314         case 1 :
5315           this.lstore_1();
5316           break;
5317         case 2 :
5318           this.lstore_2();
5319           break;
5320         case 3 :
5321           this.lstore_3();
5322           break;
5323         default :
5324           this.lstore(position);
5325       }
5326       return;
5327     }
5328     // Using dedicated double bytecode
5329     if (type == DoubleBinding) {
5330       switch (position) {
5331         case 0 :
5332           this.dstore_0();
5333           break;
5334         case 1 :
5335           this.dstore_1();
5336           break;
5337         case 2 :
5338           this.dstore_2();
5339           break;
5340         case 3 :
5341           this.dstore_3();
5342           break;
5343         default :
5344           this.dstore(position);
5345       }
5346       return;
5347     }
5348     // Reference object
5349     switch (position) {
5350       case 0 :
5351         this.astore_0();
5352         break;
5353       case 1 :
5354         this.astore_1();
5355         break;
5356       case 2 :
5357         this.astore_2();
5358         break;
5359       case 3 :
5360         this.astore_3();
5361         break;
5362       default :
5363         this.astore(position);
5364     }
5365   }
5366   public final void storeInt(int position) {
5367     switch (position) {
5368       case 0 :
5369         this.istore_0();
5370         break;
5371       case 1 :
5372         this.istore_1();
5373         break;
5374       case 2 :
5375         this.istore_2();
5376         break;
5377       case 3 :
5378         this.istore_3();
5379         break;
5380       default :
5381         this.istore(position);
5382     }
5383   }
5384   public final void storeObject(int position) {
5385     switch (position) {
5386       case 0 :
5387         this.astore_0();
5388         break;
5389       case 1 :
5390         this.astore_1();
5391         break;
5392       case 2 :
5393         this.astore_2();
5394         break;
5395       case 3 :
5396         this.astore_3();
5397         break;
5398       default :
5399         this.astore(position);
5400     }
5401   }
5402   final public void swap() {
5403     countLabels = 0;
5404     try {
5405       position++;
5406       bCodeStream[classFileOffset++] = OPC_swap;
5407     } catch (IndexOutOfBoundsException e) {
5408       resizeByteArray(OPC_swap);
5409     }
5410   }
5411   private static final void swap(int a[], int i, int j, int result[]) {
5412     int T;
5413     T = a[i];
5414     a[i] = a[j];
5415     a[j] = T;
5416     T = result[j];
5417     result[j] = result[i];
5418     result[i] = T;
5419   }
5420   final public void tableswitch(
5421     CaseLabel defaultLabel,
5422     int low,
5423     int high,
5424     int[] keys,
5425     int[] sortedIndexes,
5426     CaseLabel[] casesLabel) {
5427     countLabels = 0;
5428     stackDepth--;
5429     int length = casesLabel.length;
5430     int pos = position;
5431     defaultLabel.placeInstruction();
5432     for (int i = 0; i < length; i++)
5433       casesLabel[i].placeInstruction();
5434     try {
5435       position++;
5436       bCodeStream[classFileOffset++] = OPC_tableswitch;
5437     } catch (IndexOutOfBoundsException e) {
5438       resizeByteArray(OPC_tableswitch);
5439     }
5440     for (int i = (3 - (pos % 4)); i > 0; i--) {
5441       position++; // Padding
5442       classFileOffset++;
5443     }
5444     defaultLabel.branch();
5445     writeSignedWord(low);
5446     writeSignedWord(high);
5447     int i = low, j = low;
5448     // the index j is used to know if the index i is one of the missing entries in case of an
5449     // optimized tableswitch
5450     while (true) {
5451       int index;
5452       int key = keys[index = sortedIndexes[j - low]];
5453       if (key == i) {
5454         casesLabel[index].branch();
5455         j++;
5456         if (i == high)
5457           break; // if high is maxint, then avoids wrapping to minint.
5458       } else {
5459         defaultLabel.branch();
5460       }
5461       i++;
5462     }
5463   }
5464   public String toString() {
5465     StringBuffer buffer = new StringBuffer("( position:"); //$NON-NLS-1$
5466     buffer.append(position);
5467     buffer.append(",\nstackDepth:"); //$NON-NLS-1$
5468     buffer.append(stackDepth);
5469     buffer.append(",\nmaxStack:"); //$NON-NLS-1$
5470     buffer.append(stackMax);
5471     buffer.append(",\nmaxLocals:"); //$NON-NLS-1$
5472     buffer.append(maxLocals);
5473     buffer.append(")"); //$NON-NLS-1$
5474     return buffer.toString();
5475   }
5476   public void updateLastRecordedEndPC(int pos) {
5477
5478     /* Tune positions in the table, this is due to some
5479      * extra bytecodes being
5480      * added to some user code (jumps). */
5481     /** OLD CODE
5482         if (!generateLineNumberAttributes)
5483                 return;
5484         pcToSourceMap[pcToSourceMapSize - 1][1] = position;
5485         // need to update the initialization endPC in case of generation of local variable attributes.
5486         updateLocalVariablesAttribute(pos);
5487     */
5488
5489     if (!generateLineNumberAttributes)
5490       return;
5491     // need to update the initialization endPC in case of generation of local variable attributes.
5492     updateLocalVariablesAttribute(pos);
5493   }
5494   public void updateLocalVariablesAttribute(int pos) {
5495     // need to update the initialization endPC in case of generation of local variable attributes.
5496     if (generateLocalVariableTableAttributes) {
5497       for (int i = 0, max = locals.length; i < max; i++) {
5498         LocalVariableBinding local = locals[i];
5499         if ((local != null) && (local.initializationCount > 0)) {
5500           if (local.initializationPCs[((local.initializationCount - 1) << 1) + 1] == pos) {
5501             local.initializationPCs[((local.initializationCount - 1) << 1) + 1] = position;
5502           }
5503         }
5504       }
5505     }
5506   }
5507   final public void wide() {
5508     countLabels = 0;
5509     try {
5510       position++;
5511       bCodeStream[classFileOffset++] = OPC_wide;
5512     } catch (IndexOutOfBoundsException e) {
5513       resizeByteArray(OPC_wide);
5514     }
5515   }
5516   public final void writeByte(byte b) {
5517     try {
5518       position++;
5519       bCodeStream[classFileOffset++] = b;
5520     } catch (IndexOutOfBoundsException e) {
5521       resizeByteArray(b);
5522     }
5523   }
5524   public final void writeByteAtPos(int pos, byte b) {
5525     try {
5526       bCodeStream[pos] = b;
5527     } catch (IndexOutOfBoundsException ex) {
5528       resizeByteArray();
5529       bCodeStream[pos] = b;
5530     }
5531   }
5532   /**
5533    * Write a unsigned 8 bits value into the byte array
5534    * @param b the signed byte
5535    */
5536   public final void writeSignedByte(int b) {
5537     try {
5538       position++;
5539       bCodeStream[classFileOffset++] = (byte) b;
5540     } catch (IndexOutOfBoundsException e) {
5541       resizeByteArray((byte) b);
5542     }
5543   }
5544   /**
5545    * Write a signed 16 bits value into the byte array
5546    * @param b the signed short
5547    */
5548   public final void writeSignedShort(int b) {
5549     try {
5550       position++;
5551       bCodeStream[classFileOffset++] = (byte) (b >> 8);
5552     } catch (IndexOutOfBoundsException e) {
5553       resizeByteArray((byte) (b >> 8));
5554     }
5555     try {
5556       position++;
5557       bCodeStream[classFileOffset++] = (byte) b;
5558     } catch (IndexOutOfBoundsException e) {
5559       resizeByteArray((byte) b);
5560     }
5561   }
5562   public final void writeSignedShort(int pos, int b) {
5563     int currentOffset = startingClassFileOffset + pos;
5564     try {
5565       bCodeStream[currentOffset] = (byte) (b >> 8);
5566     } catch (IndexOutOfBoundsException e) {
5567       resizeByteArray();
5568       bCodeStream[currentOffset] = (byte) (b >> 8);
5569     }
5570     try {
5571       bCodeStream[currentOffset + 1] = (byte) b;
5572     } catch (IndexOutOfBoundsException e) {
5573       resizeByteArray();
5574       bCodeStream[currentOffset + 1] = (byte) b;
5575     }
5576   }
5577   public final void writeSignedWord(int value) {
5578     try {
5579       position++;
5580       bCodeStream[classFileOffset++] = (byte) ((value & 0xFF000000) >> 24);
5581     } catch (IndexOutOfBoundsException e) {
5582       resizeByteArray((byte) ((value & 0xFF000000) >> 24));
5583     }
5584     try {
5585       position++;
5586       bCodeStream[classFileOffset++] = (byte) ((value & 0xFF0000) >> 16);
5587     } catch (IndexOutOfBoundsException e) {
5588       resizeByteArray((byte) ((value & 0xFF0000) >> 16));
5589     }
5590     try {
5591       position++;
5592       bCodeStream[classFileOffset++] = (byte) ((value & 0xFF00) >> 8);
5593     } catch (IndexOutOfBoundsException e) {
5594       resizeByteArray((byte) ((value & 0xFF00) >> 8));
5595     }
5596     try {
5597       position++;
5598       bCodeStream[classFileOffset++] = (byte) (value & 0xFF);
5599     } catch (IndexOutOfBoundsException e) {
5600       resizeByteArray((byte) (value & 0xFF));
5601     }
5602   }
5603   public final void writeSignedWord(int pos, int value) {
5604     int currentOffset = startingClassFileOffset + pos;
5605     try {
5606       bCodeStream[currentOffset++] = (byte) ((value & 0xFF000000) >> 24);
5607     } catch (IndexOutOfBoundsException e) {
5608       resizeByteArray();
5609       bCodeStream[currentOffset - 1] = (byte) ((value & 0xFF000000) >> 24);
5610     }
5611     try {
5612       bCodeStream[currentOffset++] = (byte) ((value & 0xFF0000) >> 16);
5613     } catch (IndexOutOfBoundsException e) {
5614       resizeByteArray();
5615       bCodeStream[currentOffset - 1] = (byte) ((value & 0xFF0000) >> 16);
5616     }
5617     try {
5618       bCodeStream[currentOffset++] = (byte) ((value & 0xFF00) >> 8);
5619     } catch (IndexOutOfBoundsException e) {
5620       resizeByteArray();
5621       bCodeStream[currentOffset - 1] = (byte) ((value & 0xFF00) >> 8);
5622     }
5623     try {
5624       bCodeStream[currentOffset++] = (byte) (value & 0xFF);
5625     } catch (IndexOutOfBoundsException e) {
5626       resizeByteArray();
5627       bCodeStream[currentOffset - 1] = (byte) (value & 0xFF);
5628     }
5629   }
5630   /**
5631    * Write a unsigned 8 bits value into the byte array
5632    * @param b the unsigned byte
5633    */
5634   public final void writeUnsignedByte(int b) {
5635     try {
5636       position++;
5637       bCodeStream[classFileOffset++] = (byte) b;
5638     } catch (IndexOutOfBoundsException e) {
5639       resizeByteArray((byte) b);
5640     }
5641   }
5642   /**
5643    * Write a unsigned 16 bits value into the byte array
5644    * @param b the unsigned short
5645    */
5646   public final void writeUnsignedShort(int b) {
5647     try {
5648       position++;
5649       bCodeStream[classFileOffset++] = (byte) (b >>> 8);
5650     } catch (IndexOutOfBoundsException e) {
5651       resizeByteArray((byte) (b >>> 8));
5652     }
5653     try {
5654       position++;
5655       bCodeStream[classFileOffset++] = (byte) b;
5656     } catch (IndexOutOfBoundsException e) {
5657       resizeByteArray((byte) b);
5658     }
5659   }
5660   /**
5661    * Write a unsigned 32 bits value into the byte array
5662    * @param value the unsigned word
5663    */
5664   public final void writeUnsignedWord(int value) {
5665     try {
5666       position++;
5667       bCodeStream[classFileOffset++] = (byte) (value >>> 24);
5668     } catch (IndexOutOfBoundsException e) {
5669       resizeByteArray((byte) (value >>> 24));
5670     }
5671     try {
5672       position++;
5673       bCodeStream[classFileOffset++] = (byte) (value >>> 16);
5674     } catch (IndexOutOfBoundsException e) {
5675       resizeByteArray((byte) (value >>> 16));
5676     }
5677     try {
5678       position++;
5679       bCodeStream[classFileOffset++] = (byte) (value >>> 8);
5680     } catch (IndexOutOfBoundsException e) {
5681       resizeByteArray((byte) (value >>> 8));
5682     }
5683     try {
5684       position++;
5685       bCodeStream[classFileOffset++] = (byte) value;
5686     } catch (IndexOutOfBoundsException e) {
5687       resizeByteArray((byte) value);
5688     }
5689   }
5690
5691   public void generateWideConditionalBranch(byte opcode, Label lbl) {
5692     /* we handle the goto_w problem inside an if.... with some macro expansion
5693      * at the bytecode level
5694      * instead of:
5695      * if_...... lbl
5696      * we have:
5697      *    ifne <l1>
5698      *    goto <l2>
5699      * l1 gotow <l3> // l3 is a wide target
5700      * l2 ....
5701      */
5702     Label l1 = new Label(this);
5703     try {
5704       position++;
5705       bCodeStream[classFileOffset++] = opcode;
5706     } catch (IndexOutOfBoundsException e) {
5707       resizeByteArray(opcode);
5708     }
5709     l1.branch();
5710     Label l2 = new Label(this);
5711     this.internal_goto_(l2);
5712     l1.place();
5713     this.goto_w(lbl);
5714     l2.place();
5715   }
5716 }