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