net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/ClassFile.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;
  12
  13 import java.io.BufferedOutputStream;
  14 import java.io.File;
  15 import java.io.FileOutputStream;
  16 import java.io.IOException;
  17 import java.util.StringTokenizer;
  18
  19 import net.sourceforge.phpdt.core.compiler.IProblem;
  20 import net.sourceforge.phpdt.internal.compiler.ast.AbstractMethodDeclaration;
  21 import net.sourceforge.phpdt.internal.compiler.ast.Argument;
  22 import net.sourceforge.phpdt.internal.compiler.ast.AstNode;
  23 import net.sourceforge.phpdt.internal.compiler.ast.FieldDeclaration;
  24 import net.sourceforge.phpdt.internal.compiler.ast.FieldReference;
  25 import net.sourceforge.phpdt.internal.compiler.ast.MethodDeclaration;
  26 import net.sourceforge.phpdt.internal.compiler.ast.TypeDeclaration;
  27 import net.sourceforge.phpdt.internal.compiler.codegen.AttributeNamesConstants;
  28 import net.sourceforge.phpdt.internal.compiler.codegen.CodeStream;
  29 import net.sourceforge.phpdt.internal.compiler.codegen.ConstantPool;
  30 import net.sourceforge.phpdt.internal.compiler.codegen.ExceptionLabel;
  31 import net.sourceforge.phpdt.internal.compiler.codegen.QualifiedNamesConstants;
  32 import net.sourceforge.phpdt.internal.compiler.impl.CompilerOptions;
  33 import net.sourceforge.phpdt.internal.compiler.impl.Constant;
  34 import net.sourceforge.phpdt.internal.compiler.impl.StringConstant;
  35 import net.sourceforge.phpdt.internal.compiler.lookup.CompilerModifiers;
  36 import net.sourceforge.phpdt.internal.compiler.lookup.FieldBinding;
  37 import net.sourceforge.phpdt.internal.compiler.lookup.LocalTypeBinding;
  38 import net.sourceforge.phpdt.internal.compiler.lookup.LocalVariableBinding;
  39 import net.sourceforge.phpdt.internal.compiler.lookup.MethodBinding;
  40 import net.sourceforge.phpdt.internal.compiler.lookup.NestedTypeBinding;
  41 import net.sourceforge.phpdt.internal.compiler.lookup.ReferenceBinding;
  42 import net.sourceforge.phpdt.internal.compiler.lookup.SourceTypeBinding;
  43 import net.sourceforge.phpdt.internal.compiler.lookup.SyntheticAccessMethodBinding;
  44 import net.sourceforge.phpdt.internal.compiler.lookup.SyntheticArgumentBinding;
  45 import net.sourceforge.phpdt.internal.compiler.lookup.TypeBinding;
  46 import net.sourceforge.phpdt.internal.compiler.lookup.TypeConstants;
  47 import net.sourceforge.phpdt.internal.compiler.lookup.TypeIds;
  48 import net.sourceforge.phpdt.internal.compiler.problem.ProblemReporter;
  49 import net.sourceforge.phpdt.internal.compiler.util.CharOperation;
  50 import net.sourceforge.phpdt.internal.compiler.util.HashtableOfType;
  51 import net.sourceforge.phpdt.internal.compiler.util.Util;
  52
  53 /**
  54  * Represents a class file wrapper on bytes, it is aware of its actual
  55  * type name.
  56  *
  57  * Public APIs are listed below:
  58  *
  59  * byte[] getBytes();
  60  *              Answer the actual bytes of the class file
  61  *
  62  * char[][] getCompoundName();
  63  *              Answer the compound name of the class file.
  64  *              For example, {{java}, {util}, {Hashtable}}.
  65  *
  66  * byte[] getReducedBytes();
  67  *              Answer a smaller byte format, which is only contains some structural
  68  *      information. Those bytes are decodable with a regular class file reader,
  69  *      such as DietClassFileReader
  70  */
  71 public class ClassFile
  72         implements AttributeNamesConstants, CompilerModifiers, TypeConstants, TypeIds {
  73         public SourceTypeBinding referenceBinding;
  74         public ConstantPool constantPool;
  75         public ClassFile enclosingClassFile;
  76         // used to generate private access methods
  77         public int produceDebugAttributes;
  78         public ReferenceBinding[] innerClassesBindings;
  79         public int numberOfInnerClasses;
  80         public byte[] header;
  81         // the header contains all the bytes till the end of the constant pool
  82         public byte[] contents;
  83         // that collection contains all the remaining bytes of the .class file
  84         public int headerOffset;
  85         public int contentsOffset;
  86         public int constantPoolOffset;
  87         public int methodCountOffset;
  88         public int methodCount;
  89         protected boolean creatingProblemType;
  90         public static final int INITIAL_CONTENTS_SIZE = 1000;
  91         public static final int INITIAL_HEADER_SIZE = 1000;
  92         public static final int INCREMENT_SIZE = 1000;
  93         public static final int INNER_CLASSES_SIZE = 5;
  94         protected HashtableOfType nameUsage;
  95         public CodeStream codeStream;
  96         protected int problemLine;      // used to create line number attributes for problem methods
  97
  98         /**
  99          * INTERNAL USE-ONLY
 100          * This methods creates a new instance of the receiver.
 101          */
 102         public ClassFile() {
 103         }
 104
 105         /**
 106          * INTERNAL USE-ONLY
 107          * This methods creates a new instance of the receiver.
 108          *
 109          * @param aType org.eclipse.jdt.internal.compiler.lookup.SourceTypeBinding
 110          * @param enclosingClassFile org.eclipse.jdt.internal.compiler.ClassFile
 111          * @param creatingProblemType <CODE>boolean</CODE>
 112          */
 113         public ClassFile(
 114                 SourceTypeBinding aType,
 115                 ClassFile enclosingClassFile,
 116                 boolean creatingProblemType) {
 117                 referenceBinding = aType;
 118                 header = new byte[INITIAL_HEADER_SIZE];
 119                 // generate the magic numbers inside the header
 120                 header[headerOffset++] = (byte) (0xCAFEBABEL >> 24);
 121                 header[headerOffset++] = (byte) (0xCAFEBABEL >> 16);
 122                 header[headerOffset++] = (byte) (0xCAFEBABEL >> 8);
 123                 header[headerOffset++] = (byte) (0xCAFEBABEL >> 0);
 124                 switch(((SourceTypeBinding) referenceBinding).scope.environment().options.targetJDK) {
 125                         case CompilerOptions.JDK1_4 :
 126                                 // Compatible with JDK 1.4
 127                                 header[headerOffset++] = 0;
 128                                 header[headerOffset++] = 0;
 129                                 header[headerOffset++] = 0;
 130                                 header[headerOffset++] = 48;
 131                                 break;
 132                         case CompilerOptions.JDK1_3 :
 133                                 // Compatible with JDK 1.3
 134                                 header[headerOffset++] = 0;
 135                                 header[headerOffset++] = 0;
 136                                 header[headerOffset++] = 0;
 137                                 header[headerOffset++] = 47;
 138                                 break;
 139                         case CompilerOptions.JDK1_2 :
 140                                 // Compatible with JDK 1.2
 141                                 header[headerOffset++] = 0;
 142                                 header[headerOffset++] = 0;
 143                                 header[headerOffset++] = 0;
 144                                 header[headerOffset++] = 46;
 145                                 break;
 146                         case CompilerOptions.JDK1_1 :
 147                                 // Compatible with JDK 1.1
 148                                 header[headerOffset++] = 0;
 149                                 header[headerOffset++] = 3;
 150                                 header[headerOffset++] = 0;
 151                                 header[headerOffset++] = 45;
 152                 }
 153                 constantPoolOffset = headerOffset;
 154                 headerOffset += 2;
 155                 constantPool = new ConstantPool(this);
 156
 157                 // Modifier manipulations for classfile
 158                 int accessFlags = aType.getAccessFlags();
 159                 if (aType.isPrivate()) { // rewrite private to non-public
 160                         accessFlags &= ~AccPublic;
 161                 }
 162                 if (aType.isProtected()) { // rewrite protected into public
 163                         accessFlags |= AccPublic;
 164                 }
 165                 // clear all bits that are illegal for a class or an interface
 166                 accessFlags
 167                         &= ~(
 168                                 AccStrictfp
 169                                         | AccProtected
 170                                         | AccPrivate
 171                                         | AccStatic
 172                                         | AccSynchronized
 173                                         | AccNative);
 174
 175                 // set the AccSuper flag (has to be done after clearing AccSynchronized - since same value)
 176                 accessFlags |= AccSuper;
 177
 178                 this.enclosingClassFile = enclosingClassFile;
 179                 // innerclasses get their names computed at code gen time
 180                 if (aType.isLocalType()) {
 181                         ((LocalTypeBinding) aType).constantPoolName(
 182                                 computeConstantPoolName((LocalTypeBinding) aType));
 183                         ReferenceBinding[] memberTypes = aType.memberTypes();
 184                         for (int i = 0, max = memberTypes.length; i < max; i++) {
 185                                 ((LocalTypeBinding) memberTypes[i]).constantPoolName(
 186                                         computeConstantPoolName((LocalTypeBinding) memberTypes[i]));
 187                         }
 188                 }
 189                 contents = new byte[INITIAL_CONTENTS_SIZE];
 190                 // now we continue to generate the bytes inside the contents array
 191                 contents[contentsOffset++] = (byte) (accessFlags >> 8);
 192                 contents[contentsOffset++] = (byte) accessFlags;
 193                 int classNameIndex = constantPool.literalIndex(aType);
 194                 contents[contentsOffset++] = (byte) (classNameIndex >> 8);
 195                 contents[contentsOffset++] = (byte) classNameIndex;
 196                 int superclassNameIndex;
 197                 if (aType.isInterface()) {
 198                         superclassNameIndex = constantPool.literalIndexForJavaLangObject();
 199                 } else {
 200                         superclassNameIndex =
 201                                 (aType.superclass == null ? 0 : constantPool.literalIndex(aType.superclass));
 202                 }
 203                 contents[contentsOffset++] = (byte) (superclassNameIndex >> 8);
 204                 contents[contentsOffset++] = (byte) superclassNameIndex;
 205                 ReferenceBinding[] superInterfacesBinding = aType.superInterfaces();
 206                 int interfacesCount = superInterfacesBinding.length;
 207                 contents[contentsOffset++] = (byte) (interfacesCount >> 8);
 208                 contents[contentsOffset++] = (byte) interfacesCount;
 209                 if (superInterfacesBinding != null) {
 210                         for (int i = 0; i < interfacesCount; i++) {
 211                                 int interfaceIndex = constantPool.literalIndex(superInterfacesBinding[i]);
 212                                 contents[contentsOffset++] = (byte) (interfaceIndex >> 8);
 213                                 contents[contentsOffset++] = (byte) interfaceIndex;
 214                         }
 215                 }
 216                 produceDebugAttributes =
 217                         ((SourceTypeBinding) referenceBinding)
 218                                 .scope
 219                                 .environment()
 220                                 .options
 221                                 .produceDebugAttributes;
 222                 innerClassesBindings = new ReferenceBinding[INNER_CLASSES_SIZE];
 223                 this.creatingProblemType = creatingProblemType;
 224                 codeStream = new CodeStream(this);
 225
 226                 // retrieve the enclosing one guaranteed to be the one matching the propagated flow info
 227                 // 1FF9ZBU: LFCOM:ALL - Local variable attributes busted (Sanity check)
 228                 ClassFile outermostClassFile = this.outerMostEnclosingClassFile();
 229                 if (this == outermostClassFile) {
 230                         codeStream.maxFieldCount = aType.scope.referenceType().maxFieldCount;
 231                 } else {
 232                         codeStream.maxFieldCount = outermostClassFile.codeStream.maxFieldCount;
 233                 }
 234         }
 235
 236         /**
 237          * INTERNAL USE-ONLY
 238          * Generate the byte for a problem method info that correspond to a boggus method.
 239          *
 240          * @param method org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration
 241          * @param methodBinding org.eclipse.jdt.internal.compiler.nameloopkup.MethodBinding
 242          */
 243         public void addAbstractMethod(
 244                 AbstractMethodDeclaration method,
 245                 MethodBinding methodBinding) {
 246
 247                 // force the modifiers to be public and abstract
 248                 methodBinding.modifiers = AccPublic | AccAbstract;
 249
 250                 this.generateMethodInfoHeader(methodBinding);
 251                 int methodAttributeOffset = this.contentsOffset;
 252                 int attributeNumber = this.generateMethodInfoAttribute(methodBinding);
 253                 this.completeMethodInfo(methodAttributeOffset, attributeNumber);
 254         }
 255
 256         /**
 257          * INTERNAL USE-ONLY
 258          * This methods generate all the attributes for the receiver.
 259          * For a class they could be:
 260          * - source file attribute
 261          * - inner classes attribute
 262          * - deprecated attribute
 263          */
 264         public void addAttributes() {
 265                 // update the method count
 266                 contents[methodCountOffset++] = (byte) (methodCount >> 8);
 267                 contents[methodCountOffset] = (byte) methodCount;
 268
 269                 int attributeNumber = 0;
 270                 // leave two bytes for the number of attributes and store the current offset
 271                 int attributeOffset = contentsOffset;
 272                 contentsOffset += 2;
 273                 int contentsLength;
 274
 275                 // source attribute
 276                 if ((produceDebugAttributes & CompilerOptions.Source) != 0) {
 277                         String fullFileName =
 278                                 new String(referenceBinding.scope.referenceCompilationUnit().getFileName());
 279                         fullFileName = fullFileName.replace('\\', '/');
 280                         int lastIndex = fullFileName.lastIndexOf('/');
 281                         if (lastIndex != -1) {
 282                                 fullFileName = fullFileName.substring(lastIndex + 1, fullFileName.length());
 283                         }
 284                         // check that there is enough space to write all the bytes for the field info corresponding
 285                         // to the @fieldBinding
 286                         if (contentsOffset + 8 >= (contentsLength = contents.length)) {
 287                                 System.arraycopy(
 288                                         contents,
 289                                         0,
 290                                         (contents = new byte[contentsLength + INCREMENT_SIZE]),
 291                                         0,
 292                                         contentsLength);
 293                         }
 294                         int sourceAttributeNameIndex =
 295                                 constantPool.literalIndex(AttributeNamesConstants.SourceName);
 296                         contents[contentsOffset++] = (byte) (sourceAttributeNameIndex >> 8);
 297                         contents[contentsOffset++] = (byte) sourceAttributeNameIndex;
 298                         // The length of a source file attribute is 2. This is a fixed-length
 299                         // attribute
 300                         contents[contentsOffset++] = 0;
 301                         contents[contentsOffset++] = 0;
 302                         contents[contentsOffset++] = 0;
 303                         contents[contentsOffset++] = 2;
 304                         // write the source file name
 305                         int fileNameIndex = constantPool.literalIndex(fullFileName.toCharArray());
 306                         contents[contentsOffset++] = (byte) (fileNameIndex >> 8);
 307                         contents[contentsOffset++] = (byte) fileNameIndex;
 308                         attributeNumber++;
 309                 }
 310                 // Deprecated attribute
 311                 if (referenceBinding.isDeprecated()) {
 312                         // check that there is enough space to write all the bytes for the field info corresponding
 313                         // to the @fieldBinding
 314                         if (contentsOffset + 6 >= (contentsLength = contents.length)) {
 315                                 System.arraycopy(
 316                                         contents,
 317                                         0,
 318                                         (contents = new byte[contentsLength + INCREMENT_SIZE]),
 319                                         0,
 320                                         contentsLength);
 321                         }
 322                         int deprecatedAttributeNameIndex =
 323                                 constantPool.literalIndex(AttributeNamesConstants.DeprecatedName);
 324                         contents[contentsOffset++] = (byte) (deprecatedAttributeNameIndex >> 8);
 325                         contents[contentsOffset++] = (byte) deprecatedAttributeNameIndex;
 326                         // the length of a deprecated attribute is equals to 0
 327                         contents[contentsOffset++] = 0;
 328                         contents[contentsOffset++] = 0;
 329                         contents[contentsOffset++] = 0;
 330                         contents[contentsOffset++] = 0;
 331                         attributeNumber++;
 332                 }
 333                 // Inner class attribute
 334                 if (numberOfInnerClasses != 0) {
 335                         // Generate the inner class attribute
 336                         int exSize;
 337                         if (contentsOffset + (exSize = (8 * numberOfInnerClasses + 8))
 338                                 >= (contentsLength = contents.length)) {
 339                                 System.arraycopy(
 340                                         contents,
 341                                         0,
 342                                         (contents =
 343                                                 new byte[contentsLength
 344                                                         + (exSize >= INCREMENT_SIZE ? exSize : INCREMENT_SIZE)]),
 345                                         0,
 346                                         contentsLength);
 347                         }
 348                         // Now we now the size of the attribute and the number of entries
 349                         // attribute name
 350                         int attributeNameIndex =
 351                                 constantPool.literalIndex(AttributeNamesConstants.InnerClassName);
 352                         contents[contentsOffset++] = (byte) (attributeNameIndex >> 8);
 353                         contents[contentsOffset++] = (byte) attributeNameIndex;
 354                         int value = (numberOfInnerClasses << 3) + 2;
 355                         contents[contentsOffset++] = (byte) (value >> 24);
 356                         contents[contentsOffset++] = (byte) (value >> 16);
 357                         contents[contentsOffset++] = (byte) (value >> 8);
 358                         contents[contentsOffset++] = (byte) value;
 359                         contents[contentsOffset++] = (byte) (numberOfInnerClasses >> 8);
 360                         contents[contentsOffset++] = (byte) numberOfInnerClasses;
 361                         for (int i = 0; i < numberOfInnerClasses; i++) {
 362                                 ReferenceBinding innerClass = innerClassesBindings[i];
 363                                 int accessFlags = innerClass.getAccessFlags();
 364                                 int innerClassIndex = constantPool.literalIndex(innerClass);
 365                                 // inner class index
 366                                 contents[contentsOffset++] = (byte) (innerClassIndex >> 8);
 367                                 contents[contentsOffset++] = (byte) innerClassIndex;
 368                                 // outer class index: anonymous and local have no outer class index
 369                                 if (innerClass.isMemberType()) {
 370                                         // member or member of local
 371                                         int outerClassIndex = constantPool.literalIndex(innerClass.enclosingType());
 372                                         contents[contentsOffset++] = (byte) (outerClassIndex >> 8);
 373                                         contents[contentsOffset++] = (byte) outerClassIndex;
 374                                 } else {
 375                                         // equals to 0 if the innerClass is not a member type
 376                                         contents[contentsOffset++] = 0;
 377                                         contents[contentsOffset++] = 0;
 378                                 }
 379                                 // name index
 380                                 if (!innerClass.isAnonymousType()) {
 381                                         int nameIndex = constantPool.literalIndex(innerClass.sourceName());
 382                                         contents[contentsOffset++] = (byte) (nameIndex >> 8);
 383                                         contents[contentsOffset++] = (byte) nameIndex;
 384                                 } else {
 385                                         // equals to 0 if the innerClass is an anonymous type
 386                                         contents[contentsOffset++] = 0;
 387                                         contents[contentsOffset++] = 0;
 388                                 }
 389                                 // access flag
 390                                 if (innerClass.isAnonymousType()) {
 391                                         accessFlags |= AccPrivate;
 392                                 } else
 393                                         if (innerClass.isLocalType() && !innerClass.isMemberType()) {
 394                                                 accessFlags |= AccPrivate;
 395                                         }
 396                                 contents[contentsOffset++] = (byte) (accessFlags >> 8);
 397                                 contents[contentsOffset++] = (byte) accessFlags;
 398                         }
 399                         attributeNumber++;
 400                 }
 401                 // update the number of attributes
 402                 contentsLength = contents.length;
 403                 if (attributeOffset + 2 >= contentsLength) {
 404                         System.arraycopy(
 405                                 contents,
 406                                 0,
 407                                 (contents = new byte[contentsLength + INCREMENT_SIZE]),
 408                                 0,
 409                                 contentsLength);
 410                 }
 411                 contents[attributeOffset++] = (byte) (attributeNumber >> 8);
 412                 contents[attributeOffset] = (byte) attributeNumber;
 413
 414                 // resynchronize all offsets of the classfile
 415                 header = constantPool.poolContent;
 416                 headerOffset = constantPool.currentOffset;
 417                 int constantPoolCount = constantPool.currentIndex;
 418                 header[constantPoolOffset++] = (byte) (constantPoolCount >> 8);
 419                 header[constantPoolOffset] = (byte) constantPoolCount;
 420         }
 421
 422         /**
 423          * INTERNAL USE-ONLY
 424          * This methods generate all the default abstract method infos that correpond to
 425          * the abstract methods inherited from superinterfaces.
 426          */
 427         public void addDefaultAbstractMethods() { // default abstract methods
 428                 MethodBinding[] defaultAbstractMethods =
 429                         referenceBinding.getDefaultAbstractMethods();
 430                 for (int i = 0, max = defaultAbstractMethods.length; i < max; i++) {
 431                         generateMethodInfoHeader(defaultAbstractMethods[i]);
 432                         int methodAttributeOffset = contentsOffset;
 433                         int attributeNumber = generateMethodInfoAttribute(defaultAbstractMethods[i]);
 434                         completeMethodInfo(methodAttributeOffset, attributeNumber);
 435                 }
 436         }
 437
 438         /**
 439          * INTERNAL USE-ONLY
 440          * This methods generates the bytes for the field binding passed like a parameter
 441          * @param fieldBinding org.eclipse.jdt.internal.compiler.lookup.FieldBinding
 442          */
 443         public void addFieldInfo(FieldBinding fieldBinding) {
 444                 int attributeNumber = 0;
 445                 // check that there is enough space to write all the bytes for the field info corresponding
 446                 // to the @fieldBinding
 447                 int contentsLength;
 448                 if (contentsOffset + 30 >= (contentsLength = contents.length)) {
 449                         System.arraycopy(
 450                                 contents,
 451                                 0,
 452                                 (contents = new byte[contentsLength + INCREMENT_SIZE]),
 453                                 0,
 454                                 contentsLength);
 455                 }
 456                 // Generate two attribute: constantValueAttribute and SyntheticAttribute
 457                 // Now we can generate all entries into the byte array
 458                 // First the accessFlags
 459                 int accessFlags = fieldBinding.getAccessFlags();
 460                 contents[contentsOffset++] = (byte) (accessFlags >> 8);
 461                 contents[contentsOffset++] = (byte) accessFlags;
 462                 // Then the nameIndex
 463                 int nameIndex = constantPool.literalIndex(fieldBinding.name);
 464                 contents[contentsOffset++] = (byte) (nameIndex >> 8);
 465                 contents[contentsOffset++] = (byte) nameIndex;
 466                 // Then the descriptorIndex
 467                 int descriptorIndex = constantPool.literalIndex(fieldBinding.type.signature());
 468                 contents[contentsOffset++] = (byte) (descriptorIndex >> 8);
 469                 contents[contentsOffset++] = (byte) descriptorIndex;
 470                 // leave some space for the number of attributes
 471                 int fieldAttributeOffset = contentsOffset;
 472                 contentsOffset += 2;
 473                 // 4.7.2 only static constant fields get a ConstantAttribute
 474                 if (fieldBinding.constant != Constant.NotAConstant
 475                         && fieldBinding.constant.typeID() != T_null) {
 476                         // Now we generate the constant attribute corresponding to the fieldBinding
 477                         int constantValueNameIndex =
 478                                 constantPool.literalIndex(AttributeNamesConstants.ConstantValueName);
 479                         contents[contentsOffset++] = (byte) (constantValueNameIndex >> 8);
 480                         contents[contentsOffset++] = (byte) constantValueNameIndex;
 481                         // The attribute length = 2 in case of a constantValue attribute
 482                         contents[contentsOffset++] = 0;
 483                         contents[contentsOffset++] = 0;
 484                         contents[contentsOffset++] = 0;
 485                         contents[contentsOffset++] = 2;
 486                         attributeNumber++;
 487                         // Need to add the constant_value_index
 488                         switch (fieldBinding.constant.typeID()) {
 489                                 case T_boolean :
 490                                         int booleanValueIndex =
 491                                                 constantPool.literalIndex(fieldBinding.constant.booleanValue() ? 1 : 0);
 492                                         contents[contentsOffset++] = (byte) (booleanValueIndex >> 8);
 493                                         contents[contentsOffset++] = (byte) booleanValueIndex;
 494                                         break;
 495                                 case T_byte :
 496                                 case T_char :
 497                                 case T_int :
 498                                 case T_short :
 499                                         int integerValueIndex =
 500                                                 constantPool.literalIndex(fieldBinding.constant.intValue());
 501                                         contents[contentsOffset++] = (byte) (integerValueIndex >> 8);
 502                                         contents[contentsOffset++] = (byte) integerValueIndex;
 503                                         break;
 504                                 case T_float :
 505                                         int floatValueIndex =
 506                                                 constantPool.literalIndex(fieldBinding.constant.floatValue());
 507                                         contents[contentsOffset++] = (byte) (floatValueIndex >> 8);
 508                                         contents[contentsOffset++] = (byte) floatValueIndex;
 509                                         break;
 510                                 case T_double :
 511                                         int doubleValueIndex =
 512                                                 constantPool.literalIndex(fieldBinding.constant.doubleValue());
 513                                         contents[contentsOffset++] = (byte) (doubleValueIndex >> 8);
 514                                         contents[contentsOffset++] = (byte) doubleValueIndex;
 515                                         break;
 516                                 case T_long :
 517                                         int longValueIndex =
 518                                                 constantPool.literalIndex(fieldBinding.constant.longValue());
 519                                         contents[contentsOffset++] = (byte) (longValueIndex >> 8);
 520                                         contents[contentsOffset++] = (byte) longValueIndex;
 521                                         break;
 522                                 case T_String :
 523                                         int stringValueIndex =
 524                                                 constantPool.literalIndex(
 525                                                         ((StringConstant) fieldBinding.constant).stringValue());
 526                                         if (stringValueIndex == -1) {
 527                                                 if (!creatingProblemType) {
 528                                                         // report an error and abort: will lead to a problem type classfile creation
 529                                                         TypeDeclaration typeDeclaration = referenceBinding.scope.referenceContext;
 530                                                         FieldDeclaration[] fieldDecls = typeDeclaration.fields;
 531                                                         for (int i = 0, max = fieldDecls.length; i < max; i++) {
 532                                                                 if (fieldDecls[i].binding == fieldBinding) {
 533                                                                         // problem should abort
 534                                                                         typeDeclaration.scope.problemReporter().stringConstantIsExceedingUtf8Limit(
 535                                                                                 fieldDecls[i]);
 536                                                                 }
 537                                                         }
 538                                                 } else {
 539                                                         // already inside a problem type creation : no constant for this field
 540                                                         contentsOffset = fieldAttributeOffset + 2;
 541                                                         // +2 is necessary to keep the two byte space for the attribute number
 542                                                         attributeNumber--;
 543                                                 }
 544                                         } else {
 545                                                 contents[contentsOffset++] = (byte) (stringValueIndex >> 8);
 546                                                 contents[contentsOffset++] = (byte) stringValueIndex;
 547                                         }
 548                         }
 549                 }
 550                 if (fieldBinding.isSynthetic()) {
 551                         int syntheticAttributeNameIndex =
 552                                 constantPool.literalIndex(AttributeNamesConstants.SyntheticName);
 553                         contents[contentsOffset++] = (byte) (syntheticAttributeNameIndex >> 8);
 554                         contents[contentsOffset++] = (byte) syntheticAttributeNameIndex;
 555                         // the length of a synthetic attribute is equals to 0
 556                         contents[contentsOffset++] = 0;
 557                         contents[contentsOffset++] = 0;
 558                         contents[contentsOffset++] = 0;
 559                         contents[contentsOffset++] = 0;
 560                         attributeNumber++;
 561                 }
 562                 if (fieldBinding.isDeprecated()) {
 563                         int deprecatedAttributeNameIndex =
 564                                 constantPool.literalIndex(AttributeNamesConstants.DeprecatedName);
 565                         contents[contentsOffset++] = (byte) (deprecatedAttributeNameIndex >> 8);
 566                         contents[contentsOffset++] = (byte) deprecatedAttributeNameIndex;
 567                         // the length of a deprecated attribute is equals to 0
 568                         contents[contentsOffset++] = 0;
 569                         contents[contentsOffset++] = 0;
 570                         contents[contentsOffset++] = 0;
 571                         contents[contentsOffset++] = 0;
 572                         attributeNumber++;
 573                 }
 574                 contents[fieldAttributeOffset++] = (byte) (attributeNumber >> 8);
 575                 contents[fieldAttributeOffset] = (byte) attributeNumber;
 576         }
 577
 578         /**
 579          * INTERNAL USE-ONLY
 580          * This methods generate all the fields infos for the receiver.
 581          * This includes:
 582          * - a field info for each defined field of that class
 583          * - a field info for each synthetic field (e.g. this$0)
 584          */
 585         public void addFieldInfos() {
 586                 SourceTypeBinding currentBinding = referenceBinding;
 587                 FieldBinding[] syntheticFields = currentBinding.syntheticFields();
 588                 int fieldCount =
 589                         currentBinding.fieldCount()
 590                                 + (syntheticFields == null ? 0 : syntheticFields.length);
 591
 592                 // write the number of fields
 593                 contents[contentsOffset++] = (byte) (fieldCount >> 8);
 594                 contents[contentsOffset++] = (byte) fieldCount;
 595
 596                 FieldBinding[] fieldBindings = currentBinding.fields();
 597                 for (int i = 0, max = fieldBindings.length; i < max; i++) {
 598                         addFieldInfo(fieldBindings[i]);
 599                 }
 600                 if (syntheticFields != null) {
 601                         for (int i = 0, max = syntheticFields.length; i < max; i++) {
 602                                 addFieldInfo(syntheticFields[i]);
 603                         }
 604                 }
 605         }
 606
 607         /**
 608          * INTERNAL USE-ONLY
 609          * This methods stores the bindings for each inner class. They will be used to know which entries
 610          * have to be generated for the inner classes attributes.
 611          * @param referenceBinding org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding
 612          */
 613         public void addInnerClasses(ReferenceBinding referenceBinding) {
 614                 // check first if that reference binding is there
 615                 for (int i = 0; i < numberOfInnerClasses; i++) {
 616                         if (innerClassesBindings[i] == referenceBinding)
 617                                 return;
 618                 }
 619                 int length = innerClassesBindings.length;
 620                 if (numberOfInnerClasses == length) {
 621                         System.arraycopy(
 622                                 innerClassesBindings,
 623                                 0,
 624                                 (innerClassesBindings = new ReferenceBinding[length * 2]),
 625                                 0,
 626                                 length);
 627                 }
 628                 innerClassesBindings[numberOfInnerClasses++] = referenceBinding;
 629         }
 630
 631         /**
 632          * INTERNAL USE-ONLY
 633          * Generate the byte for a problem clinit method info that correspond to a boggus method.
 634          *
 635          * @param problem org.eclipse.jdt.internal.compiler.problem.Problem[]
 636          */
 637         public void addProblemClinit(IProblem[] problems) {
 638                 generateMethodInfoHeaderForClinit();
 639                 // leave two spaces for the number of attributes
 640                 contentsOffset -= 2;
 641                 int attributeOffset = contentsOffset;
 642                 contentsOffset += 2;
 643                 int attributeNumber = 0;
 644
 645                 int codeAttributeOffset = contentsOffset;
 646                 generateCodeAttributeHeader();
 647                 codeStream.resetForProblemClinit(this);
 648                 String problemString = "" ; //$NON-NLS-1$
 649                 if (problems != null) {
 650                         int max = problems.length;
 651                         StringBuffer buffer = new StringBuffer(25);
 652                         int count = 0;
 653                         for (int i = 0; i < max; i++) {
 654                                 IProblem problem = problems[i];
 655                                 if ((problem != null) && (problem.isError())) {
 656                                         buffer.append("\t"  +problem.getMessage() + "\n" ); //$NON-NLS-1$ //$NON-NLS-2$
 657                                         count++;
 658                                         if (problemLine == 0) {
 659                                                 problemLine = problem.getSourceLineNumber();
 660                                         }
 661                                         problems[i] = null;
 662                                 }
 663                         } // insert the top line afterwards, once knowing how many problems we have to consider
 664                         if (count > 1) {
 665                                 buffer.insert(0, Util.bind("compilation.unresolvedProblems" )); //$NON-NLS-1$
 666                         } else {
 667                                 buffer.insert(0, Util.bind("compilation.unresolvedProblem" )); //$NON-NLS-1$
 668                         }
 669                         problemString = buffer.toString();
 670                 }
 671
 672                 // return codeStream.generateCodeAttributeForProblemMethod(comp.options.runtimeExceptionNameForCompileError, "")
 673                 int[] exceptionHandler =
 674                         codeStream.generateCodeAttributeForProblemMethod(
 675                                 referenceBinding
 676                                         .scope
 677                                         .environment()
 678                                         .options
 679                                         .runtimeExceptionNameForCompileError,
 680                                 problemString);
 681                 attributeNumber++; // code attribute
 682                 completeCodeAttributeForClinit(
 683                         codeAttributeOffset,
 684                         exceptionHandler,
 685                         referenceBinding
 686                                 .scope
 687                                 .referenceCompilationUnit()
 688                                 .compilationResult
 689                                 .lineSeparatorPositions);
 690                 contents[attributeOffset++] = (byte) (attributeNumber >> 8);
 691                 contents[attributeOffset] = (byte) attributeNumber;
 692         }
 693
 694         /**
 695          * INTERNAL USE-ONLY
 696          * Generate the byte for a problem method info that correspond to a boggus constructor.
 697          *
 698          * @param method org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration
 699          * @param methodBinding org.eclipse.jdt.internal.compiler.nameloopkup.MethodBinding
 700          * @param problem org.eclipse.jdt.internal.compiler.problem.Problem[]
 701          */
 702         public void addProblemConstructor(
 703                 AbstractMethodDeclaration method,
 704                 MethodBinding methodBinding,
 705                 IProblem[] problems) {
 706
 707                 // always clear the strictfp/native/abstract bit for a problem method
 708                 methodBinding.modifiers &= ~(AccStrictfp | AccNative | AccAbstract);
 709
 710                 generateMethodInfoHeader(methodBinding);
 711                 int methodAttributeOffset = contentsOffset;
 712                 int attributeNumber = generateMethodInfoAttribute(methodBinding);
 713
 714                 // Code attribute
 715                 attributeNumber++;
 716                 int codeAttributeOffset = contentsOffset;
 717                 generateCodeAttributeHeader();
 718                 final ProblemReporter problemReporter = method.scope.problemReporter();
 719                 codeStream.reset(method, this);
 720                 String problemString = "" ; //$NON-NLS-1$
 721                 if (problems != null) {
 722                         int max = problems.length;
 723                         StringBuffer buffer = new StringBuffer(25);
 724                         int count = 0;
 725                         for (int i = 0; i < max; i++) {
 726                                 IProblem problem = problems[i];
 727                                 if ((problem != null) && (problem.isError())) {
 728                                         buffer.append("\t"  +problem.getMessage() + "\n" ); //$NON-NLS-1$ //$NON-NLS-2$
 729                                         count++;
 730                                         if (problemLine == 0) {
 731                                                 problemLine = problem.getSourceLineNumber();
 732                                         }
 733                                 }
 734                         } // insert the top line afterwards, once knowing how many problems we have to consider
 735                         if (count > 1) {
 736                                 buffer.insert(0, Util.bind("compilation.unresolvedProblems" )); //$NON-NLS-1$
 737                         } else {
 738                                 buffer.insert(0, Util.bind("compilation.unresolvedProblem" )); //$NON-NLS-1$
 739                         }
 740                         problemString = buffer.toString();
 741                 }
 742
 743                 // return codeStream.generateCodeAttributeForProblemMethod(comp.options.runtimeExceptionNameForCompileError, "")
 744                 int[] exceptionHandler =
 745                         codeStream.generateCodeAttributeForProblemMethod(
 746                                 problemReporter.options.runtimeExceptionNameForCompileError,
 747                                 problemString);
 748                 completeCodeAttributeForProblemMethod(
 749                         method,
 750                         methodBinding,
 751                         codeAttributeOffset,
 752                         exceptionHandler,
 753                         ((SourceTypeBinding) methodBinding.declaringClass)
 754                                 .scope
 755                                 .referenceCompilationUnit()
 756                                 .compilationResult
 757                                 .lineSeparatorPositions);
 758                 completeMethodInfo(methodAttributeOffset, attributeNumber);
 759         }
 760
 761         /**
 762          * INTERNAL USE-ONLY
 763          * Generate the byte for a problem method info that correspond to a boggus constructor.
 764          * Reset the position inside the contents byte array to the savedOffset.
 765          *
 766          * @param method org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration
 767          * @param methodBinding org.eclipse.jdt.internal.compiler.nameloopkup.MethodBinding
 768          * @param problem org.eclipse.jdt.internal.compiler.problem.Problem[]
 769          * @param savedOffset <CODE>int</CODE>
 770          */
 771         public void addProblemConstructor(
 772                 AbstractMethodDeclaration method,
 773                 MethodBinding methodBinding,
 774                 IProblem[] problems,
 775                 int savedOffset) {
 776                 // we need to move back the contentsOffset to the value at the beginning of the method
 777                 contentsOffset = savedOffset;
 778                 methodCount--; // we need to remove the method that causes the problem
 779                 addProblemConstructor(method, methodBinding, problems);
 780         }
 781
 782         /**
 783          * INTERNAL USE-ONLY
 784          * Generate the byte for a problem method info that correspond to a boggus method.
 785          *
 786          * @param method org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration
 787          * @param methodBinding org.eclipse.jdt.internal.compiler.nameloopkup.MethodBinding
 788          * @param problem org.eclipse.jdt.internal.compiler.problem.Problem[]
 789          */
 790         public void addProblemMethod(
 791                 AbstractMethodDeclaration method,
 792                 MethodBinding methodBinding,
 793                 IProblem[] problems) {
 794                 if (methodBinding.isAbstract() && methodBinding.declaringClass.isInterface()) {
 795                         method.abort(AbstractMethodDeclaration.AbortType);
 796                 }
 797                 // always clear the strictfp/native/abstract bit for a problem method
 798                 methodBinding.modifiers &= ~(AccStrictfp | AccNative | AccAbstract);
 799
 800                 generateMethodInfoHeader(methodBinding);
 801                 int methodAttributeOffset = contentsOffset;
 802                 int attributeNumber = generateMethodInfoAttribute(methodBinding);
 803
 804                 // Code attribute
 805                 attributeNumber++;
 806
 807                 int codeAttributeOffset = contentsOffset;
 808                 generateCodeAttributeHeader();
 809                 final ProblemReporter problemReporter = method.scope.problemReporter();
 810                 codeStream.reset(method, this);
 811                 String problemString = "" ; //$NON-NLS-1$
 812                 if (problems != null) {
 813                         int max = problems.length;
 814                         StringBuffer buffer = new StringBuffer(25);
 815                         int count = 0;
 816                         for (int i = 0; i < max; i++) {
 817                                 IProblem problem = problems[i];
 818                                 if ((problem != null)
 819                                         && (problem.isError())
 820                                         && (problem.getSourceStart() >= method.declarationSourceStart)
 821                                         && (problem.getSourceEnd() <= method.declarationSourceEnd)) {
 822                                         buffer.append("\t"  +problem.getMessage() + "\n" ); //$NON-NLS-1$ //$NON-NLS-2$
 823                                         count++;
 824                                         if (problemLine == 0) {
 825                                                 problemLine = problem.getSourceLineNumber();
 826                                         }
 827                                         problems[i] = null;
 828                                 }
 829                         } // insert the top line afterwards, once knowing how many problems we have to consider
 830                         if (count > 1) {
 831                                 buffer.insert(0, Util.bind("compilation.unresolvedProblems" )); //$NON-NLS-1$
 832                         } else {
 833                                 buffer.insert(0, Util.bind("compilation.unresolvedProblem" )); //$NON-NLS-1$
 834                         }
 835                         problemString = buffer.toString();
 836                 }
 837
 838                 // return codeStream.generateCodeAttributeForProblemMethod(comp.options.runtimeExceptionNameForCompileError, "")
 839                 int[] exceptionHandler =
 840                         codeStream.generateCodeAttributeForProblemMethod(
 841                                 problemReporter.options.runtimeExceptionNameForCompileError,
 842                                 problemString);
 843                 completeCodeAttributeForProblemMethod(
 844                         method,
 845                         methodBinding,
 846                         codeAttributeOffset,
 847                         exceptionHandler,
 848                         ((SourceTypeBinding) methodBinding.declaringClass)
 849                                 .scope
 850                                 .referenceCompilationUnit()
 851                                 .compilationResult
 852                                 .lineSeparatorPositions);
 853                 completeMethodInfo(methodAttributeOffset, attributeNumber);
 854         }
 855
 856         /**
 857          * INTERNAL USE-ONLY
 858          * Generate the byte for a problem method info that correspond to a boggus method.
 859          * Reset the position inside the contents byte array to the savedOffset.
 860          *
 861          * @param method org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration
 862          * @param methodBinding org.eclipse.jdt.internal.compiler.nameloopkup.MethodBinding
 863          * @param problem org.eclipse.jdt.internal.compiler.problem.Problem[]
 864          * @param savedOffset <CODE>int</CODE>
 865          */
 866         public void addProblemMethod(
 867                 AbstractMethodDeclaration method,
 868                 MethodBinding methodBinding,
 869                 IProblem[] problems,
 870                 int savedOffset) {
 871                 // we need to move back the contentsOffset to the value at the beginning of the method
 872                 contentsOffset = savedOffset;
 873                 methodCount--; // we need to remove the method that causes the problem
 874                 addProblemMethod(method, methodBinding, problems);
 875         }
 876
 877         /**
 878          * INTERNAL USE-ONLY
 879          * Generate the byte for all the special method infos.
 880          * They are:
 881          * - synthetic access methods
 882          * - default abstract methods
 883          */
 884         public void addSpecialMethods() {
 885                 // add all methods (default abstract methods and synthetic)
 886
 887                 // default abstract methods
 888                 SourceTypeBinding currentBinding = referenceBinding;
 889                 MethodBinding[] defaultAbstractMethods =
 890                         currentBinding.getDefaultAbstractMethods();
 891                 for (int i = 0, max = defaultAbstractMethods.length; i < max; i++) {
 892                         generateMethodInfoHeader(defaultAbstractMethods[i]);
 893                         int methodAttributeOffset = contentsOffset;
 894                         int attributeNumber = generateMethodInfoAttribute(defaultAbstractMethods[i]);
 895                         completeMethodInfo(methodAttributeOffset, attributeNumber);
 896                 }
 897                 // add synthetic methods infos
 898                 SyntheticAccessMethodBinding[] syntheticAccessMethods =
 899                         currentBinding.syntheticAccessMethods();
 900                 if (syntheticAccessMethods != null) {
 901                         for (int i = 0, max = syntheticAccessMethods.length; i < max; i++) {
 902                                 SyntheticAccessMethodBinding accessMethodBinding = syntheticAccessMethods[i];
 903                                 switch (accessMethodBinding.accessType) {
 904                                         case SyntheticAccessMethodBinding.FieldReadAccess :
 905                                                 // generate a method info to emulate an reading access to
 906                                                 // a private field
 907                                                 addSyntheticFieldReadAccessMethod(syntheticAccessMethods[i]);
 908                                                 break;
 909                                         case SyntheticAccessMethodBinding.FieldWriteAccess :
 910                                                 // generate a method info to emulate an writing access to
 911                                                 // a private field
 912                                                 addSyntheticFieldWriteAccessMethod(syntheticAccessMethods[i]);
 913                                                 break;
 914                                         case SyntheticAccessMethodBinding.MethodAccess :
 915                                                 // generate a method info to emulate an access to a private method
 916                                                 addSyntheticMethodAccessMethod(syntheticAccessMethods[i]);
 917                                                 break;
 918                                         case SyntheticAccessMethodBinding.ConstructorAccess :
 919                                                 // generate a method info to emulate an access to a private method
 920                                                 addSyntheticConstructorAccessMethod(syntheticAccessMethods[i]);
 921                                 }
 922                         }
 923                 }
 924         }
 925
 926         /**
 927          * INTERNAL USE-ONLY
 928          * Generate the byte for problem method infos that correspond to missing abstract methods.
 929          * http://dev.eclipse.org/bugs/show_bug.cgi?id=3179
 930          *
 931          * @param methodDeclarations Array of all missing abstract methods
 932          */
 933         public void generateMissingAbstractMethods(MethodDeclaration[] methodDeclarations, CompilationResult compilationResult) {
 934                 if (methodDeclarations != null) {
 935                         for (int i = 0, max = methodDeclarations.length; i < max; i++) {
 936                                 MethodDeclaration methodDeclaration = methodDeclarations[i];
 937                                 MethodBinding methodBinding = methodDeclaration.binding;
 938                                 String readableName = new String(methodBinding.readableName());
 939                                 IProblem[] problems = compilationResult.problems;
 940                                 int problemsCount = compilationResult.problemCount;
 941                                 for (int j = 0; j < problemsCount; j++) {
 942                                         IProblem problem = problems[j];
 943                                         if (problem != null
 944                                                 && problem.getID() == IProblem.AbstractMethodMustBeImplemented
 945                                                 && problem.getMessage().indexOf(readableName) != -1) {
 946                                                         // we found a match
 947                                                         addMissingAbstractProblemMethod(methodDeclaration, methodBinding, problem, compilationResult);
 948                                                 }
 949                                 }
 950                         }
 951                 }
 952         }
 953
 954         private void addMissingAbstractProblemMethod(MethodDeclaration methodDeclaration, MethodBinding methodBinding, IProblem problem, CompilationResult compilationResult) {
 955                 // always clear the strictfp/native/abstract bit for a problem method
 956                 methodBinding.modifiers &= ~(AccStrictfp | AccNative | AccAbstract);
 957
 958                 generateMethodInfoHeader(methodBinding);
 959                 int methodAttributeOffset = contentsOffset;
 960                 int attributeNumber = generateMethodInfoAttribute(methodBinding);
 961
 962                 // Code attribute
 963                 attributeNumber++;
 964
 965                 int codeAttributeOffset = contentsOffset;
 966                 generateCodeAttributeHeader();
 967                 StringBuffer buffer = new StringBuffer(25);
 968                 buffer.append("\t"  + problem.getMessage() + "\n" ); //$NON-NLS-1$ //$NON-NLS-2$
 969                 buffer.insert(0, Util.bind("compilation.unresolvedProblem" )); //$NON-NLS-1$
 970                 String problemString = buffer.toString();
 971                 this.problemLine = problem.getSourceLineNumber();
 972
 973                 final ProblemReporter problemReporter = methodDeclaration.scope.problemReporter();
 974                 codeStream.init(this);
 975                 codeStream.preserveUnusedLocals = true;
 976                 codeStream.initializeMaxLocals(methodBinding);
 977
 978                 // return codeStream.generateCodeAttributeForProblemMethod(comp.options.runtimeExceptionNameForCompileError, "")
 979                 int[] exceptionHandler =
 980                         codeStream.generateCodeAttributeForProblemMethod(
 981                                 problemReporter.options.runtimeExceptionNameForCompileError,
 982                                 problemString);
 983
 984                 completeCodeAttributeForMissingAbstractProblemMethod(
 985                         methodBinding,
 986                         codeAttributeOffset,
 987                         exceptionHandler,
 988                         compilationResult.lineSeparatorPositions);
 989
 990                 completeMethodInfo(methodAttributeOffset, attributeNumber);
 991         }
 992
 993         /**
 994          *
 995          */
 996         public void completeCodeAttributeForMissingAbstractProblemMethod(
 997                 MethodBinding binding,
 998                 int codeAttributeOffset,
 999                 int[] exceptionHandler,
1000                 int[] startLineIndexes) {
1001                 // reinitialize the localContents with the byte modified by the code stream
1002                 byte[] localContents = contents = codeStream.bCodeStream;
1003                 int localContentsOffset = codeStream.classFileOffset;
1004                 // codeAttributeOffset is the position inside localContents byte array before we started to write// any information about the codeAttribute// That means that to write the attribute_length you need to offset by 2 the value of codeAttributeOffset// to get the right position, 6 for the max_stack etc...
1005                 int max_stack = codeStream.stackMax;
1006                 localContents[codeAttributeOffset + 6] = (byte) (max_stack >> 8);
1007                 localContents[codeAttributeOffset + 7] = (byte) max_stack;
1008                 int max_locals = codeStream.maxLocals;
1009                 localContents[codeAttributeOffset + 8] = (byte) (max_locals >> 8);
1010                 localContents[codeAttributeOffset + 9] = (byte) max_locals;
1011                 int code_length = codeStream.position;
1012                 localContents[codeAttributeOffset + 10] = (byte) (code_length >> 24);
1013                 localContents[codeAttributeOffset + 11] = (byte) (code_length >> 16);
1014                 localContents[codeAttributeOffset + 12] = (byte) (code_length >> 8);
1015                 localContents[codeAttributeOffset + 13] = (byte) code_length;
1016                 // write the exception table
1017                 int contentsLength;
1018                 if (localContentsOffset + 50 >= (contentsLength = localContents.length)) {
1019                         System.arraycopy(
1020                                 contents,
1021                                 0,
1022                                 (localContents = contents = new byte[contentsLength + INCREMENT_SIZE]),
1023                                 0,
1024                                 contentsLength);
1025                 }
1026                 localContents[localContentsOffset++] = 0;
1027                 localContents[localContentsOffset++] = 1;
1028                 int start = exceptionHandler[0];
1029                 localContents[localContentsOffset++] = (byte) (start >> 8);
1030                 localContents[localContentsOffset++] = (byte) start;
1031                 int end = exceptionHandler[1];
1032                 localContents[localContentsOffset++] = (byte) (end >> 8);
1033                 localContents[localContentsOffset++] = (byte) end;
1034                 int handlerPC = exceptionHandler[2];
1035                 localContents[localContentsOffset++] = (byte) (handlerPC >> 8);
1036                 localContents[localContentsOffset++] = (byte) handlerPC;
1037                 int nameIndex = constantPool.literalIndexForJavaLangException();
1038                 localContents[localContentsOffset++] = (byte) (nameIndex >> 8);
1039                 localContents[localContentsOffset++] = (byte) nameIndex; // debug attributes
1040                 int codeAttributeAttributeOffset = localContentsOffset;
1041                 int attributeNumber = 0; // leave two bytes for the attribute_length
1042                 localContentsOffset += 2; // first we handle the linenumber attribute
1043
1044                 if (codeStream.generateLineNumberAttributes) {
1045                         /* Create and add the line number attribute (used for debugging)
1046                             * Build the pairs of:
1047                             * (bytecodePC lineNumber)
1048                             * according to the table of start line indexes and the pcToSourceMap table
1049                             * contained into the codestream
1050                             */
1051                         int lineNumberNameIndex =
1052                                 constantPool.literalIndex(AttributeNamesConstants.LineNumberTableName);
1053                         localContents[localContentsOffset++] = (byte) (lineNumberNameIndex >> 8);
1054                         localContents[localContentsOffset++] = (byte) lineNumberNameIndex;
1055                         localContents[localContentsOffset++] = 0;
1056                         localContents[localContentsOffset++] = 0;
1057                         localContents[localContentsOffset++] = 0;
1058                         localContents[localContentsOffset++] = 6;
1059                         localContents[localContentsOffset++] = 0;
1060                         localContents[localContentsOffset++] = 1;
1061                         if (problemLine == 0) {
1062                                 problemLine = searchLineNumber(startLineIndexes, binding.sourceStart());
1063                         }
1064                         // first entry at pc = 0
1065                         localContents[localContentsOffset++] = 0;
1066                         localContents[localContentsOffset++] = 0;
1067                         localContents[localContentsOffset++] = (byte) (problemLine >> 8);
1068                         localContents[localContentsOffset++] = (byte) problemLine;
1069                         // now we change the size of the line number attribute
1070                         attributeNumber++;
1071                 }
1072
1073                 // then we do the local variable attribute
1074                 // update the number of attributes// ensure first that there is enough space available inside the localContents array
1075                 if (codeAttributeAttributeOffset + 2
1076                         >= (contentsLength = localContents.length)) {
1077                         System.arraycopy(
1078                                 contents,
1079                                 0,
1080                                 (localContents = contents = new byte[contentsLength + INCREMENT_SIZE]),
1081                                 0,
1082                                 contentsLength);
1083                 }
1084                 localContents[codeAttributeAttributeOffset++] = (byte) (attributeNumber >> 8);
1085                 localContents[codeAttributeAttributeOffset] = (byte) attributeNumber;
1086                 // update the attribute length
1087                 int codeAttributeLength = localContentsOffset - (codeAttributeOffset + 6);
1088                 localContents[codeAttributeOffset + 2] = (byte) (codeAttributeLength >> 24);
1089                 localContents[codeAttributeOffset + 3] = (byte) (codeAttributeLength >> 16);
1090                 localContents[codeAttributeOffset + 4] = (byte) (codeAttributeLength >> 8);
1091                 localContents[codeAttributeOffset + 5] = (byte) codeAttributeLength;
1092                 contentsOffset = localContentsOffset;
1093         }
1094
1095         /**
1096          * INTERNAL USE-ONLY
1097          * Generate the byte for a problem method info that correspond to a synthetic method that
1098          * generate an access to a private constructor.
1099          *
1100          * @param methodBinding org.eclipse.jdt.internal.compiler.nameloopkup.SyntheticAccessMethodBinding
1101          */
1102         public void addSyntheticConstructorAccessMethod(SyntheticAccessMethodBinding methodBinding) {
1103                 generateMethodInfoHeader(methodBinding);
1104                 // We know that we won't get more than 2 attribute: the code attribute + synthetic attribute
1105                 contents[contentsOffset++] = 0;
1106                 contents[contentsOffset++] = 2;
1107                 // Code attribute
1108                 int codeAttributeOffset = contentsOffset;
1109                 generateCodeAttributeHeader();
1110                 codeStream.init(this);
1111                 codeStream.generateSyntheticBodyForConstructorAccess(methodBinding);
1112                 completeCodeAttributeForSyntheticAccessMethod(
1113                         methodBinding,
1114                         codeAttributeOffset,
1115                         ((SourceTypeBinding) methodBinding.declaringClass)
1116                                 .scope
1117                                 .referenceCompilationUnit()
1118                                 .compilationResult
1119                                 .lineSeparatorPositions);
1120                 // add the synthetic attribute
1121                 int syntheticAttributeNameIndex =
1122                         constantPool.literalIndex(AttributeNamesConstants.SyntheticName);
1123                 contents[contentsOffset++] = (byte) (syntheticAttributeNameIndex >> 8);
1124                 contents[contentsOffset++] = (byte) syntheticAttributeNameIndex;
1125                 // the length of a synthetic attribute is equals to 0
1126                 contents[contentsOffset++] = 0;
1127                 contents[contentsOffset++] = 0;
1128                 contents[contentsOffset++] = 0;
1129                 contents[contentsOffset++] = 0;
1130         }
1131
1132         /**
1133          * INTERNAL USE-ONLY
1134          * Generate the byte for a problem method info that correspond to a synthetic method that
1135          * generate an read access to a private field.
1136          *
1137          * @param methodBinding org.eclipse.jdt.internal.compiler.nameloopkup.SyntheticAccessMethodBinding
1138          */
1139         public void addSyntheticFieldReadAccessMethod(SyntheticAccessMethodBinding methodBinding) {
1140                 generateMethodInfoHeader(methodBinding);
1141                 // We know that we won't get more than 2 attribute: the code attribute + synthetic attribute
1142                 contents[contentsOffset++] = 0;
1143                 contents[contentsOffset++] = 2;
1144                 // Code attribute
1145                 int codeAttributeOffset = contentsOffset;
1146                 generateCodeAttributeHeader();
1147                 codeStream.init(this);
1148                 codeStream.generateSyntheticBodyForFieldReadAccess(methodBinding);
1149                 completeCodeAttributeForSyntheticAccessMethod(
1150                         methodBinding,
1151                         codeAttributeOffset,
1152                         ((SourceTypeBinding) methodBinding.declaringClass)
1153                                 .scope
1154                                 .referenceCompilationUnit()
1155                                 .compilationResult
1156                                 .lineSeparatorPositions);
1157                 // add the synthetic attribute
1158                 int syntheticAttributeNameIndex =
1159                         constantPool.literalIndex(AttributeNamesConstants.SyntheticName);
1160                 contents[contentsOffset++] = (byte) (syntheticAttributeNameIndex >> 8);
1161                 contents[contentsOffset++] = (byte) syntheticAttributeNameIndex;
1162                 // the length of a synthetic attribute is equals to 0
1163                 contents[contentsOffset++] = 0;
1164                 contents[contentsOffset++] = 0;
1165                 contents[contentsOffset++] = 0;
1166                 contents[contentsOffset++] = 0;
1167         }
1168
1169         /**
1170          * INTERNAL USE-ONLY
1171          * Generate the byte for a problem method info that correspond to a synthetic method that
1172          * generate an write access to a private field.
1173          *
1174          * @param methodBinding org.eclipse.jdt.internal.compiler.nameloopkup.SyntheticAccessMethodBinding
1175          */
1176         public void addSyntheticFieldWriteAccessMethod(SyntheticAccessMethodBinding methodBinding) {
1177                 generateMethodInfoHeader(methodBinding);
1178                 // We know that we won't get more than 2 attribute: the code attribute + synthetic attribute
1179                 contents[contentsOffset++] = 0;
1180                 contents[contentsOffset++] = 2;
1181                 // Code attribute
1182                 int codeAttributeOffset = contentsOffset;
1183                 generateCodeAttributeHeader();
1184                 codeStream.init(this);
1185                 codeStream.generateSyntheticBodyForFieldWriteAccess(methodBinding);
1186                 completeCodeAttributeForSyntheticAccessMethod(
1187                         methodBinding,
1188                         codeAttributeOffset,
1189                         ((SourceTypeBinding) methodBinding.declaringClass)
1190                                 .scope
1191                                 .referenceCompilationUnit()
1192                                 .compilationResult
1193                                 .lineSeparatorPositions);
1194                 // add the synthetic attribute
1195                 int syntheticAttributeNameIndex =
1196                         constantPool.literalIndex(AttributeNamesConstants.SyntheticName);
1197                 contents[contentsOffset++] = (byte) (syntheticAttributeNameIndex >> 8);
1198                 contents[contentsOffset++] = (byte) syntheticAttributeNameIndex;
1199                 // the length of a synthetic attribute is equals to 0
1200                 contents[contentsOffset++] = 0;
1201                 contents[contentsOffset++] = 0;
1202                 contents[contentsOffset++] = 0;
1203                 contents[contentsOffset++] = 0;
1204         }
1205
1206         /**
1207          * INTERNAL USE-ONLY
1208          * Generate the byte for a problem method info that correspond to a synthetic method that
1209          * generate an access to a private method.
1210          *
1211          * @param methodBinding org.eclipse.jdt.internal.compiler.nameloopkup.SyntheticAccessMethodBinding
1212          */
1213         public void addSyntheticMethodAccessMethod(SyntheticAccessMethodBinding methodBinding) {
1214                 generateMethodInfoHeader(methodBinding);
1215                 // We know that we won't get more than 2 attribute: the code attribute + synthetic attribute
1216                 contents[contentsOffset++] = 0;
1217                 contents[contentsOffset++] = 2;
1218                 // Code attribute
1219                 int codeAttributeOffset = contentsOffset;
1220                 generateCodeAttributeHeader();
1221                 codeStream.init(this);
1222                 codeStream.generateSyntheticBodyForMethodAccess(methodBinding);
1223                 completeCodeAttributeForSyntheticAccessMethod(
1224                         methodBinding,
1225                         codeAttributeOffset,
1226                         ((SourceTypeBinding) methodBinding.declaringClass)
1227                                 .scope
1228                                 .referenceCompilationUnit()
1229                                 .compilationResult
1230                                 .lineSeparatorPositions);
1231                 // add the synthetic attribute
1232                 int syntheticAttributeNameIndex =
1233                         constantPool.literalIndex(AttributeNamesConstants.SyntheticName);
1234                 contents[contentsOffset++] = (byte) (syntheticAttributeNameIndex >> 8);
1235                 contents[contentsOffset++] = (byte) syntheticAttributeNameIndex;
1236                 // the length of a synthetic attribute is equals to 0
1237                 contents[contentsOffset++] = 0;
1238                 contents[contentsOffset++] = 0;
1239                 contents[contentsOffset++] = 0;
1240                 contents[contentsOffset++] = 0;
1241         }
1242
1243         /**
1244          * INTERNAL USE-ONLY
1245          * Build all the directories and subdirectories corresponding to the packages names
1246          * into the directory specified in parameters.
1247          *
1248          * outputPath is formed like:
1249          *         c:\temp\ the last character is a file separator
1250          * relativeFileName is formed like:
1251          *     java\lang\String.class *
1252          *
1253          * @param outputPath java.lang.String
1254          * @param relativeFileName java.lang.String
1255          * @return java.lang.String
1256          */
1257         public static String buildAllDirectoriesInto(
1258                 String outputPath,
1259                 String relativeFileName)
1260                 throws IOException {
1261                 char fileSeparatorChar = File.separatorChar;
1262                 String fileSeparator = File.separator;
1263                 File f;
1264                 // First we ensure that the outputPath exists
1265                 outputPath = outputPath.replace('/', fileSeparatorChar);
1266                 // To be able to pass the mkdirs() method we need to remove the extra file separator at the end of the outDir name
1267                 if (outputPath.endsWith(fileSeparator)) {
1268                         outputPath = outputPath.substring(0, outputPath.length() - 1);
1269                 }
1270                 f = new File(outputPath);
1271                 if (f.exists()) {
1272                         if (!f.isDirectory()) {
1273                                 System.out.println(Util.bind("output.isFile" , f.getAbsolutePath())); //$NON-NLS-1$
1274                                 throw new IOException(Util.bind("output.isFileNotDirectory" )); //$NON-NLS-1$
1275                         }
1276                 } else {
1277                         // we have to create that directory
1278                         if (!f.mkdirs()) {
1279                                 System.out.println(Util.bind("output.dirName" , f.getAbsolutePath())); //$NON-NLS-1$
1280                                 throw new IOException(Util.bind("output.notValidAll" )); //$NON-NLS-1$
1281                         }
1282                 }
1283                 StringBuffer outDir = new StringBuffer(outputPath);
1284                 outDir.append(fileSeparator);
1285                 StringTokenizer tokenizer =
1286                         new StringTokenizer(relativeFileName, fileSeparator);
1287                 String token = tokenizer.nextToken();
1288                 while (tokenizer.hasMoreTokens()) {
1289                         f = new File(outDir.append(token).append(fileSeparator).toString());
1290                         if (f.exists()) {
1291                                 // The outDir already exists, so we proceed the next entry
1292                                 // System.out.println("outDir: " + outDir + " already exists.");
1293                         } else {
1294                                 // Need to add the outDir
1295                                 if (!f.mkdir()) {
1296                                         System.out.println(Util.bind("output.fileName" , f.getName())); //$NON-NLS-1$
1297                                         throw new IOException(Util.bind("output.notValid" )); //$NON-NLS-1$
1298                                 }
1299                         }
1300                         token = tokenizer.nextToken();
1301                 }
1302                 // token contains the last one
1303                 return outDir.append(token).toString();
1304         }
1305
1306         /**
1307          * INTERNAL USE-ONLY
1308          * That method completes the creation of the code attribute by setting
1309          * - the attribute_length
1310          * - max_stack
1311          * - max_locals
1312          * - code_length
1313          * - exception table
1314          * - and debug attributes if necessary.
1315          *
1316          * @param codeStream org.eclipse.jdt.internal.compiler.codegen.CodeStream
1317          * @param codeAttributeOffset <CODE>int</CODE>
1318          */
1319         public void completeCodeAttribute(int codeAttributeOffset) {
1320                 // reinitialize the localContents with the byte modified by the code stream
1321                 byte[] localContents = contents = codeStream.bCodeStream;
1322                 int localContentsOffset = codeStream.classFileOffset;
1323                 // codeAttributeOffset is the position inside localContents byte array before we started to write
1324                 // any information about the codeAttribute
1325                 // That means that to write the attribute_length you need to offset by 2 the value of codeAttributeOffset
1326                 // to get the right position, 6 for the max_stack etc...
1327                 int contentsLength;
1328                 int code_length = codeStream.position;
1329                 if (code_length > 65535) {
1330                         codeStream.methodDeclaration.scope.problemReporter().bytecodeExceeds64KLimit(
1331                                 codeStream.methodDeclaration);
1332                 }
1333                 if (localContentsOffset + 20 >= (contentsLength = localContents.length)) {
1334                         System.arraycopy(
1335                                 contents,
1336                                 0,
1337                                 (localContents = contents = new byte[contentsLength + INCREMENT_SIZE]),
1338                                 0,
1339                                 contentsLength);
1340                 }
1341                 int max_stack = codeStream.stackMax;
1342                 localContents[codeAttributeOffset + 6] = (byte) (max_stack >> 8);
1343                 localContents[codeAttributeOffset + 7] = (byte) max_stack;
1344                 int max_locals = codeStream.maxLocals;
1345                 localContents[codeAttributeOffset + 8] = (byte) (max_locals >> 8);
1346                 localContents[codeAttributeOffset + 9] = (byte) max_locals;
1347                 localContents[codeAttributeOffset + 10] = (byte) (code_length >> 24);
1348                 localContents[codeAttributeOffset + 11] = (byte) (code_length >> 16);
1349                 localContents[codeAttributeOffset + 12] = (byte) (code_length >> 8);
1350                 localContents[codeAttributeOffset + 13] = (byte) code_length;
1351
1352                 // write the exception table
1353                 int exceptionHandlersNumber = codeStream.exceptionHandlersNumber;
1354                 ExceptionLabel[] exceptionHandlers = codeStream.exceptionHandlers;
1355                 int exSize;
1356                 if (localContentsOffset + (exSize = (exceptionHandlersNumber * 8 + 2))
1357                         >= (contentsLength = localContents.length)) {
1358                         System.arraycopy(
1359                                 contents,
1360                                 0,
1361                                 (localContents =
1362                                         contents =
1363                                                 new byte[contentsLength + (exSize > INCREMENT_SIZE ? exSize : INCREMENT_SIZE)]),
1364                                 0,
1365                                 contentsLength);
1366                 }
1367                 // there is no exception table, so we need to offset by 2 the current offset and move
1368                 // on the attribute generation
1369                 localContents[localContentsOffset++] = (byte) (exceptionHandlersNumber >> 8);
1370                 localContents[localContentsOffset++] = (byte) exceptionHandlersNumber;
1371                 for (int i = 0; i < exceptionHandlersNumber; i++) {
1372                         ExceptionLabel exceptionHandler = exceptionHandlers[i];
1373                         int start = exceptionHandler.start;
1374                         localContents[localContentsOffset++] = (byte) (start >> 8);
1375                         localContents[localContentsOffset++] = (byte) start;
1376                         int end = exceptionHandler.end;
1377                         localContents[localContentsOffset++] = (byte) (end >> 8);
1378                         localContents[localContentsOffset++] = (byte) end;
1379                         int handlerPC = exceptionHandler.position;
1380                         localContents[localContentsOffset++] = (byte) (handlerPC >> 8);
1381                         localContents[localContentsOffset++] = (byte) handlerPC;
1382                         if (exceptionHandler.exceptionType == null) {
1383                                 // any exception handler
1384                                 localContents[localContentsOffset++] = 0;
1385                                 localContents[localContentsOffset++] = 0;
1386                         } else {
1387                                 int nameIndex;
1388                                 if (exceptionHandler.exceptionType == TypeBinding.NullBinding) {
1389                                         /* represents ClassNotFoundException, see class literal access*/
1390                                         nameIndex = constantPool.literalIndexForJavaLangClassNotFoundException();
1391                                 } else {
1392                                         nameIndex = constantPool.literalIndex(exceptionHandler.exceptionType);
1393                                 }
1394                                 localContents[localContentsOffset++] = (byte) (nameIndex >> 8);
1395                                 localContents[localContentsOffset++] = (byte) nameIndex;
1396                         }
1397                 }
1398                 // debug attributes
1399                 int codeAttributeAttributeOffset = localContentsOffset;
1400                 int attributeNumber = 0;
1401                 // leave two bytes for the attribute_length
1402                 localContentsOffset += 2;
1403
1404                 // first we handle the linenumber attribute
1405                 if (codeStream.generateLineNumberAttributes) {
1406                         /* Create and add the line number attribute (used for debugging)
1407                          * Build the pairs of:
1408                          *      (bytecodePC lineNumber)
1409                          * according to the table of start line indexes and the pcToSourceMap table
1410                          * contained into the codestream
1411                          */
1412                         int[] pcToSourceMapTable;
1413                         if (((pcToSourceMapTable = codeStream.pcToSourceMap) != null)
1414                                 && (codeStream.pcToSourceMapSize != 0)) {
1415                                 int lineNumberNameIndex =
1416                                         constantPool.literalIndex(AttributeNamesConstants.LineNumberTableName);
1417                                 if (localContentsOffset + 8 >= (contentsLength = localContents.length)) {
1418                                         System.arraycopy(
1419                                                 contents,
1420                                                 0,
1421                                                 (localContents = contents = new byte[contentsLength + INCREMENT_SIZE]),
1422                                                 0,
1423                                                 contentsLength);
1424                                 }
1425                                 localContents[localContentsOffset++] = (byte) (lineNumberNameIndex >> 8);
1426                                 localContents[localContentsOffset++] = (byte) lineNumberNameIndex;
1427                                 int lineNumberTableOffset = localContentsOffset;
1428                                 localContentsOffset += 6;
1429                                 // leave space for attribute_length and line_number_table_length
1430                                 int numberOfEntries = 0;
1431                                 int length = codeStream.pcToSourceMapSize;
1432                                 for (int i = 0; i < length;) {
1433                                         // write the entry
1434                                         if (localContentsOffset + 4 >= (contentsLength = localContents.length)) {
1435                                                 System.arraycopy(
1436                                                         contents,
1437                                                         0,
1438                                                         (localContents = contents = new byte[contentsLength + INCREMENT_SIZE]),
1439                                                         0,
1440                                                         contentsLength);
1441                                         }
1442                                         int pc = pcToSourceMapTable[i++];
1443                                         localContents[localContentsOffset++] = (byte) (pc >> 8);
1444                                         localContents[localContentsOffset++] = (byte) pc;
1445                                         int lineNumber = pcToSourceMapTable[i++];
1446                                         localContents[localContentsOffset++] = (byte) (lineNumber >> 8);
1447                                         localContents[localContentsOffset++] = (byte) lineNumber;
1448                                         numberOfEntries++;
1449                                 }
1450                                 // now we change the size of the line number attribute
1451                                 int lineNumberAttr_length = numberOfEntries * 4 + 2;
1452                                 localContents[lineNumberTableOffset++] = (byte) (lineNumberAttr_length >> 24);
1453                                 localContents[lineNumberTableOffset++] = (byte) (lineNumberAttr_length >> 16);
1454                                 localContents[lineNumberTableOffset++] = (byte) (lineNumberAttr_length >> 8);
1455                                 localContents[lineNumberTableOffset++] = (byte) lineNumberAttr_length;
1456                                 localContents[lineNumberTableOffset++] = (byte) (numberOfEntries >> 8);
1457                                 localContents[lineNumberTableOffset++] = (byte) numberOfEntries;
1458                                 attributeNumber++;
1459                         }
1460                 }
1461                 // then we do the local variable attribute
1462                 if (codeStream.generateLocalVariableTableAttributes) {
1463                         int localVariableTableOffset = localContentsOffset;
1464                         int numberOfEntries = 0;
1465                         int localVariableNameIndex =
1466                                 constantPool.literalIndex(AttributeNamesConstants.LocalVariableTableName);
1467                         if (localContentsOffset + 8 >= (contentsLength = localContents.length)) {
1468                                 System.arraycopy(
1469                                         contents,
1470                                         0,
1471                                         (localContents = contents = new byte[contentsLength + INCREMENT_SIZE]),
1472                                         0,
1473                                         contentsLength);
1474                         }
1475                         localContents[localContentsOffset++] = (byte) (localVariableNameIndex >> 8);
1476                         localContents[localContentsOffset++] = (byte) localVariableNameIndex;
1477                         localContentsOffset += 6;
1478                         // leave space for attribute_length and local_variable_table_length
1479                         int nameIndex;
1480                         int descriptorIndex;
1481                         if (!codeStream.methodDeclaration.isStatic()) {
1482                                 numberOfEntries++;
1483                                 if (localContentsOffset + 10 >= (contentsLength = localContents.length)) {
1484                                         System.arraycopy(
1485                                                 contents,
1486                                                 0,
1487                                                 (localContents = contents = new byte[contentsLength + INCREMENT_SIZE]),
1488                                                 0,
1489                                                 contentsLength);
1490                                 }
1491                                 localContentsOffset += 2; // the startPC for this is always 0
1492                                 localContents[localContentsOffset++] = (byte) (code_length >> 8);
1493                                 localContents[localContentsOffset++] = (byte) code_length;
1494                                 nameIndex = constantPool.literalIndex(QualifiedNamesConstants.This);
1495                                 localContents[localContentsOffset++] = (byte) (nameIndex >> 8);
1496                                 localContents[localContentsOffset++] = (byte) nameIndex;
1497                                 descriptorIndex =
1498                                         constantPool.literalIndex(
1499                                                 codeStream.methodDeclaration.binding.declaringClass.signature());
1500                                 localContents[localContentsOffset++] = (byte) (descriptorIndex >> 8);
1501                                 localContents[localContentsOffset++] = (byte) descriptorIndex;
1502                                 localContentsOffset += 2; // the resolved position for this is always 0
1503                         }
1504                         for (int i = 0; i < codeStream.allLocalsCounter; i++) {
1505                                 LocalVariableBinding localVariable = codeStream.locals[i];
1506                                 for (int j = 0; j < localVariable.initializationCount; j++) {
1507                                         int startPC = localVariable.initializationPCs[j << 1];
1508                                         int endPC = localVariable.initializationPCs[(j << 1) + 1];
1509                                         if (startPC != endPC) { // only entries for non zero length
1510                                                 if (endPC == -1) {
1511                                                         localVariable.declaringScope.problemReporter().abortDueToInternalError(
1512                                                                 Util.bind("abort.invalidAttribute" , new String(localVariable.name)), //$NON-NLS-1$
1513                                                                 (AstNode) localVariable.declaringScope.methodScope().referenceContext);
1514                                                 }
1515                                                 if (localContentsOffset + 10 >= (contentsLength = localContents.length)) {
1516                                                         System.arraycopy(
1517                                                                 contents,
1518                                                                 0,
1519                                                                 (localContents = contents = new byte[contentsLength + INCREMENT_SIZE]),
1520                                                                 0,
1521                                                                 contentsLength);
1522                                                 }
1523                                                 // now we can safely add the local entry
1524                                                 numberOfEntries++;
1525                                                 localContents[localContentsOffset++] = (byte) (startPC >> 8);
1526                                                 localContents[localContentsOffset++] = (byte) startPC;
1527                                                 int length = endPC - startPC;
1528                                                 localContents[localContentsOffset++] = (byte) (length >> 8);
1529                                                 localContents[localContentsOffset++] = (byte) length;
1530                                                 nameIndex = constantPool.literalIndex(localVariable.name);
1531                                                 localContents[localContentsOffset++] = (byte) (nameIndex >> 8);
1532                                                 localContents[localContentsOffset++] = (byte) nameIndex;
1533                                                 descriptorIndex = constantPool.literalIndex(localVariable.type.signature());
1534                                                 localContents[localContentsOffset++] = (byte) (descriptorIndex >> 8);
1535                                                 localContents[localContentsOffset++] = (byte) descriptorIndex;
1536                                                 int resolvedPosition = localVariable.resolvedPosition;
1537                                                 localContents[localContentsOffset++] = (byte) (resolvedPosition >> 8);
1538                                                 localContents[localContentsOffset++] = (byte) resolvedPosition;
1539                                         }
1540                                 }
1541                         }
1542                         int value = numberOfEntries * 10 + 2;
1543                         localVariableTableOffset += 2;
1544                         localContents[localVariableTableOffset++] = (byte) (value >> 24);
1545                         localContents[localVariableTableOffset++] = (byte) (value >> 16);
1546                         localContents[localVariableTableOffset++] = (byte) (value >> 8);
1547                         localContents[localVariableTableOffset++] = (byte) value;
1548                         localContents[localVariableTableOffset++] = (byte) (numberOfEntries >> 8);
1549                         localContents[localVariableTableOffset] = (byte) numberOfEntries;
1550                         attributeNumber++;
1551                 }
1552                 // update the number of attributes
1553                 // ensure first that there is enough space available inside the localContents array
1554                 if (codeAttributeAttributeOffset + 2
1555                         >= (contentsLength = localContents.length)) {
1556                         System.arraycopy(
1557                                 contents,
1558                                 0,
1559                                 (localContents = contents = new byte[contentsLength + INCREMENT_SIZE]),
1560                                 0,
1561                                 contentsLength);
1562                 }
1563                 localContents[codeAttributeAttributeOffset++] = (byte) (attributeNumber >> 8);
1564                 localContents[codeAttributeAttributeOffset] = (byte) attributeNumber;
1565
1566                 // update the attribute length
1567                 int codeAttributeLength = localContentsOffset - (codeAttributeOffset + 6);
1568                 localContents[codeAttributeOffset + 2] = (byte) (codeAttributeLength >> 24);
1569                 localContents[codeAttributeOffset + 3] = (byte) (codeAttributeLength >> 16);
1570                 localContents[codeAttributeOffset + 4] = (byte) (codeAttributeLength >> 8);
1571                 localContents[codeAttributeOffset + 5] = (byte) codeAttributeLength;
1572                 contentsOffset = localContentsOffset;
1573         }
1574
1575         /**
1576          * INTERNAL USE-ONLY
1577          * That method completes the creation of the code attribute by setting
1578          * - the attribute_length
1579          * - max_stack
1580          * - max_locals
1581          * - code_length
1582          * - exception table
1583          * - and debug attributes if necessary.
1584          *
1585          * @param codeStream org.eclipse.jdt.internal.compiler.codegen.CodeStream
1586          * @param codeAttributeOffset <CODE>int</CODE>
1587          */
1588         public void completeCodeAttributeForClinit(int codeAttributeOffset) {
1589                 // reinitialize the contents with the byte modified by the code stream
1590                 byte[] localContents = contents = codeStream.bCodeStream;
1591                 int localContentsOffset = codeStream.classFileOffset;
1592                 // codeAttributeOffset is the position inside contents byte array before we started to write
1593                 // any information about the codeAttribute
1594                 // That means that to write the attribute_length you need to offset by 2 the value of codeAttributeOffset
1595                 // to get the right position, 6 for the max_stack etc...
1596                 int contentsLength;
1597                 int code_length = codeStream.position;
1598                 if (code_length > 65535) {
1599                         codeStream.methodDeclaration.scope.problemReporter().bytecodeExceeds64KLimit(
1600                                 codeStream.methodDeclaration.scope.referenceType());
1601                 }
1602                 if (localContentsOffset + 20 >= (contentsLength = localContents.length)) {
1603                         System.arraycopy(
1604                                 contents,
1605                                 0,
1606                                 (localContents = contents = new byte[contentsLength + INCREMENT_SIZE]),
1607                                 0,
1608                                 contentsLength);
1609                 }
1610                 int max_stack = codeStream.stackMax;
1611                 localContents[codeAttributeOffset + 6] = (byte) (max_stack >> 8);
1612                 localContents[codeAttributeOffset + 7] = (byte) max_stack;
1613                 int max_locals = codeStream.maxLocals;
1614                 localContents[codeAttributeOffset + 8] = (byte) (max_locals >> 8);
1615                 localContents[codeAttributeOffset + 9] = (byte) max_locals;
1616                 localContents[codeAttributeOffset + 10] = (byte) (code_length >> 24);
1617                 localContents[codeAttributeOffset + 11] = (byte) (code_length >> 16);
1618                 localContents[codeAttributeOffset + 12] = (byte) (code_length >> 8);
1619                 localContents[codeAttributeOffset + 13] = (byte) code_length;
1620
1621                 // write the exception table
1622                 int exceptionHandlersNumber = codeStream.exceptionHandlersNumber;
1623                 ExceptionLabel[] exceptionHandlers = codeStream.exceptionHandlers;
1624                 int exSize;
1625                 if (localContentsOffset + (exSize = (exceptionHandlersNumber * 8 + 2))
1626                         >= (contentsLength = localContents.length)) {
1627                         System.arraycopy(
1628                                 contents,
1629                                 0,
1630                                 (localContents =
1631                                         contents =
1632                                                 new byte[contentsLength + (exSize > INCREMENT_SIZE ? exSize : INCREMENT_SIZE)]),
1633                                 0,
1634                                 contentsLength);
1635                 }
1636                 // there is no exception table, so we need to offset by 2 the current offset and move
1637                 // on the attribute generation
1638                 localContents[localContentsOffset++] = (byte) (exceptionHandlersNumber >> 8);
1639                 localContents[localContentsOffset++] = (byte) exceptionHandlersNumber;
1640                 for (int i = 0; i < exceptionHandlersNumber; i++) {
1641                         ExceptionLabel exceptionHandler = exceptionHandlers[i];
1642                         int start = exceptionHandler.start;
1643                         localContents[localContentsOffset++] = (byte) (start >> 8);
1644                         localContents[localContentsOffset++] = (byte) start;
1645                         int end = exceptionHandler.end;
1646                         localContents[localContentsOffset++] = (byte) (end >> 8);
1647                         localContents[localContentsOffset++] = (byte) end;
1648                         int handlerPC = exceptionHandler.position;
1649                         localContents[localContentsOffset++] = (byte) (handlerPC >> 8);
1650                         localContents[localContentsOffset++] = (byte) handlerPC;
1651                         if (exceptionHandler.exceptionType == null) {
1652                                 // any exception handler
1653                                 localContentsOffset += 2;
1654                         } else {
1655                                 int nameIndex;
1656                                 if (exceptionHandler.exceptionType == TypeBinding.NullBinding) {
1657                                         /* represents denote ClassNotFoundException, see class literal access*/
1658                                         nameIndex = constantPool.literalIndexForJavaLangClassNotFoundException();
1659                                 } else {
1660                                         nameIndex = constantPool.literalIndex(exceptionHandler.exceptionType);
1661                                 }
1662                                 localContents[localContentsOffset++] = (byte) (nameIndex >> 8);
1663                                 localContents[localContentsOffset++] = (byte) nameIndex;
1664                         }
1665                 }
1666                 // debug attributes
1667                 int codeAttributeAttributeOffset = localContentsOffset;
1668                 int attributeNumber = 0;
1669                 // leave two bytes for the attribute_length
1670                 localContentsOffset += 2;
1671
1672                 // first we handle the linenumber attribute
1673                 if (codeStream.generateLineNumberAttributes) {
1674                         /* Create and add the line number attribute (used for debugging)
1675                          * Build the pairs of:
1676                          *      (bytecodePC lineNumber)
1677                          * according to the table of start line indexes and the pcToSourceMap table
1678                          * contained into the codestream
1679                          */
1680                         int[] pcToSourceMapTable;
1681                         if (((pcToSourceMapTable = codeStream.pcToSourceMap) != null)
1682                                 && (codeStream.pcToSourceMapSize != 0)) {
1683                                 int lineNumberNameIndex =
1684                                         constantPool.literalIndex(AttributeNamesConstants.LineNumberTableName);
1685                                 if (localContentsOffset + 8 >= (contentsLength = localContents.length)) {
1686                                         System.arraycopy(
1687                                                 contents,
1688                                                 0,
1689                                                 (localContents = contents = new byte[contentsLength + INCREMENT_SIZE]),
1690                                                 0,
1691                                                 contentsLength);
1692                                 }
1693                                 localContents[localContentsOffset++] = (byte) (lineNumberNameIndex >> 8);
1694                                 localContents[localContentsOffset++] = (byte) lineNumberNameIndex;
1695                                 int lineNumberTableOffset = localContentsOffset;
1696                                 localContentsOffset += 6;
1697                                 // leave space for attribute_length and line_number_table_length
1698                                 int numberOfEntries = 0;
1699                                 int length = codeStream.pcToSourceMapSize;
1700                                 for (int i = 0; i < length;) {
1701                                         // write the entry
1702                                         if (localContentsOffset + 4 >= (contentsLength = localContents.length)) {
1703                                                 System.arraycopy(
1704                                                         contents,
1705                                                         0,
1706                                                         (localContents = contents = new byte[contentsLength + INCREMENT_SIZE]),
1707                                                         0,
1708                                                         contentsLength);
1709                                         }
1710                                         int pc = pcToSourceMapTable[i++];
1711                                         localContents[localContentsOffset++] = (byte) (pc >> 8);
1712                                         localContents[localContentsOffset++] = (byte) pc;
1713                                         int lineNumber = pcToSourceMapTable[i++];
1714                                         localContents[localContentsOffset++] = (byte) (lineNumber >> 8);
1715                                         localContents[localContentsOffset++] = (byte) lineNumber;
1716                                         numberOfEntries++;
1717                                 }
1718                                 // now we change the size of the line number attribute
1719                                 int lineNumberAttr_length = numberOfEntries * 4 + 2;
1720                                 localContents[lineNumberTableOffset++] = (byte) (lineNumberAttr_length >> 24);
1721                                 localContents[lineNumberTableOffset++] = (byte) (lineNumberAttr_length >> 16);
1722                                 localContents[lineNumberTableOffset++] = (byte) (lineNumberAttr_length >> 8);
1723                                 localContents[lineNumberTableOffset++] = (byte) lineNumberAttr_length;
1724                                 localContents[lineNumberTableOffset++] = (byte) (numberOfEntries >> 8);
1725                                 localContents[lineNumberTableOffset++] = (byte) numberOfEntries;
1726                                 attributeNumber++;
1727                         }
1728                 }
1729                 // then we do the local variable attribute
1730                 if (codeStream.generateLocalVariableTableAttributes) {
1731                         int localVariableTableOffset = localContentsOffset;
1732                         int numberOfEntries = 0;
1733                         //              codeAttribute.addLocalVariableTableAttribute(this);
1734                         if ((codeStream.pcToSourceMap != null)
1735                                 && (codeStream.pcToSourceMapSize != 0)) {
1736                                 int localVariableNameIndex =
1737                                         constantPool.literalIndex(AttributeNamesConstants.LocalVariableTableName);
1738                                 if (localContentsOffset + 8 >= (contentsLength = localContents.length)) {
1739                                         System.arraycopy(
1740                                                 contents,
1741                                                 0,
1742                                                 (localContents = contents = new byte[contentsLength + INCREMENT_SIZE]),
1743                                                 0,
1744                                                 contentsLength);
1745                                 }
1746                                 localContents[localContentsOffset++] = (byte) (localVariableNameIndex >> 8);
1747                                 localContents[localContentsOffset++] = (byte) localVariableNameIndex;
1748                                 localContentsOffset += 6;
1749                                 // leave space for attribute_length and local_variable_table_length
1750                                 int nameIndex;
1751                                 int descriptorIndex;
1752                                 for (int i = 0; i < codeStream.allLocalsCounter; i++) {
1753                                         LocalVariableBinding localVariable = codeStream.locals[i];
1754                                         for (int j = 0; j < localVariable.initializationCount; j++) {
1755                                                 int startPC = localVariable.initializationPCs[j << 1];
1756                                                 int endPC = localVariable.initializationPCs[(j << 1) + 1];
1757                                                 if (startPC != endPC) { // only entries for non zero length
1758                                                         if (endPC == -1) {
1759                                                                 localVariable.declaringScope.problemReporter().abortDueToInternalError(
1760                                                                         Util.bind("abort.invalidAttribute" , new String(localVariable.name)), //$NON-NLS-1$
1761                                                                         (AstNode) localVariable.declaringScope.methodScope().referenceContext);
1762                                                         }
1763                                                         if (localContentsOffset + 10 >= (contentsLength = localContents.length)) {
1764                                                                 System.arraycopy(
1765                                                                         contents,
1766                                                                         0,
1767                                                                         (localContents = contents = new byte[contentsLength + INCREMENT_SIZE]),
1768                                                                         0,
1769                                                                         contentsLength);
1770                                                         }
1771                                                         // now we can safely add the local entry
1772                                                         numberOfEntries++;
1773                                                         localContents[localContentsOffset++] = (byte) (startPC >> 8);
1774                                                         localContents[localContentsOffset++] = (byte) startPC;
1775                                                         int length = endPC - startPC;
1776                                                         localContents[localContentsOffset++] = (byte) (length >> 8);
1777                                                         localContents[localContentsOffset++] = (byte) length;
1778                                                         nameIndex = constantPool.literalIndex(localVariable.name);
1779                                                         localContents[localContentsOffset++] = (byte) (nameIndex >> 8);
1780                                                         localContents[localContentsOffset++] = (byte) nameIndex;
1781                                                         descriptorIndex = constantPool.literalIndex(localVariable.type.signature());
1782                                                         localContents[localContentsOffset++] = (byte) (descriptorIndex >> 8);
1783                                                         localContents[localContentsOffset++] = (byte) descriptorIndex;
1784                                                         int resolvedPosition = localVariable.resolvedPosition;
1785                                                         localContents[localContentsOffset++] = (byte) (resolvedPosition >> 8);
1786                                                         localContents[localContentsOffset++] = (byte) resolvedPosition;
1787                                                 }
1788                                         }
1789                                 }
1790                                 int value = numberOfEntries * 10 + 2;
1791                                 localVariableTableOffset += 2;
1792                                 localContents[localVariableTableOffset++] = (byte) (value >> 24);
1793                                 localContents[localVariableTableOffset++] = (byte) (value >> 16);
1794                                 localContents[localVariableTableOffset++] = (byte) (value >> 8);
1795                                 localContents[localVariableTableOffset++] = (byte) value;
1796                                 localContents[localVariableTableOffset++] = (byte) (numberOfEntries >> 8);
1797                                 localContents[localVariableTableOffset] = (byte) numberOfEntries;
1798                                 attributeNumber++;
1799                         }
1800                 }
1801                 // update the number of attributes
1802                 // ensure first that there is enough space available inside the contents array
1803                 if (codeAttributeAttributeOffset + 2
1804                         >= (contentsLength = localContents.length)) {
1805                         System.arraycopy(
1806                                 contents,
1807                                 0,
1808                                 (localContents = contents = new byte[contentsLength + INCREMENT_SIZE]),
1809                                 0,
1810                                 contentsLength);
1811                 }
1812                 localContents[codeAttributeAttributeOffset++] = (byte) (attributeNumber >> 8);
1813                 localContents[codeAttributeAttributeOffset] = (byte) attributeNumber;
1814                 // update the attribute length
1815                 int codeAttributeLength = localContentsOffset - (codeAttributeOffset + 6);
1816                 localContents[codeAttributeOffset + 2] = (byte) (codeAttributeLength >> 24);
1817                 localContents[codeAttributeOffset + 3] = (byte) (codeAttributeLength >> 16);
1818                 localContents[codeAttributeOffset + 4] = (byte) (codeAttributeLength >> 8);
1819                 localContents[codeAttributeOffset + 5] = (byte) codeAttributeLength;
1820                 contentsOffset = localContentsOffset;
1821         }
1822
1823         /**
1824          * INTERNAL USE-ONLY
1825          * That method completes the creation of the code attribute by setting
1826          * - the attribute_length
1827          * - max_stack
1828          * - max_locals
1829          * - code_length
1830          * - exception table
1831          * - and debug attributes if necessary.
1832          *
1833          * @param codeStream org.eclipse.jdt.internal.compiler.codegen.CodeStream
1834          * @param codeAttributeOffset <CODE>int</CODE>
1835          * @param exceptionHandler int[]
1836          * @param startIndexes int[]
1837          */
1838         public void completeCodeAttributeForClinit(
1839                 int codeAttributeOffset,
1840                 int[] exceptionHandler,
1841                 int[] startLineIndexes) {
1842                 // reinitialize the contents with the byte modified by the code stream
1843                 byte[] localContents = contents = codeStream.bCodeStream;
1844                 int localContentsOffset = codeStream.classFileOffset;
1845                 // codeAttributeOffset is the position inside contents byte array before we started to write
1846                 // any information about the codeAttribute
1847                 // That means that to write the attribute_length you need to offset by 2 the value of codeAttributeOffset
1848                 // to get the right position, 6 for the max_stack etc...
1849                 int contentsLength;
1850                 int code_length = codeStream.position;
1851                 if (code_length > 65535) {
1852                         codeStream.methodDeclaration.scope.problemReporter().bytecodeExceeds64KLimit(
1853                                 codeStream.methodDeclaration.scope.referenceType());
1854                 }
1855                 if (localContentsOffset + 20 >= (contentsLength = localContents.length)) {
1856                         System.arraycopy(
1857                                 contents,
1858                                 0,
1859                                 (localContents = contents = new byte[contentsLength + INCREMENT_SIZE]),
1860                                 0,
1861                                 contentsLength);
1862                 }
1863                 int max_stack = codeStream.stackMax;
1864                 localContents[codeAttributeOffset + 6] = (byte) (max_stack >> 8);
1865                 localContents[codeAttributeOffset + 7] = (byte) max_stack;
1866                 int max_locals = codeStream.maxLocals;
1867                 localContents[codeAttributeOffset + 8] = (byte) (max_locals >> 8);
1868                 localContents[codeAttributeOffset + 9] = (byte) max_locals;
1869                 localContents[codeAttributeOffset + 10] = (byte) (code_length >> 24);
1870                 localContents[codeAttributeOffset + 11] = (byte) (code_length >> 16);
1871                 localContents[codeAttributeOffset + 12] = (byte) (code_length >> 8);
1872                 localContents[codeAttributeOffset + 13] = (byte) code_length;
1873
1874                 // write the exception table
1875                 localContents[localContentsOffset++] = 0;
1876                 localContents[localContentsOffset++] = 1;
1877                 int start = exceptionHandler[0];
1878                 localContents[localContentsOffset++] = (byte) (start >> 8);
1879                 localContents[localContentsOffset++] = (byte) start;
1880                 int end = exceptionHandler[1];
1881                 localContents[localContentsOffset++] = (byte) (end >> 8);
1882                 localContents[localContentsOffset++] = (byte) end;
1883                 int handlerPC = exceptionHandler[2];
1884                 localContents[localContentsOffset++] = (byte) (handlerPC >> 8);
1885                 localContents[localContentsOffset++] = (byte) handlerPC;
1886                 int nameIndex = constantPool.literalIndexForJavaLangException();
1887                 localContents[localContentsOffset++] = (byte) (nameIndex >> 8);
1888                 localContents[localContentsOffset++] = (byte) nameIndex;
1889
1890                 // debug attributes
1891                 int codeAttributeAttributeOffset = localContentsOffset;
1892                 int attributeNumber = 0; // leave two bytes for the attribute_length
1893                 localContentsOffset += 2; // first we handle the linenumber attribute
1894
1895                 // first we handle the linenumber attribute
1896                 if (codeStream.generateLineNumberAttributes) {
1897                         /* Create and add the line number attribute (used for debugging)
1898                             * Build the pairs of:
1899                             * (bytecodePC lineNumber)
1900                             * according to the table of start line indexes and the pcToSourceMap table
1901                             * contained into the codestream
1902                             */
1903                         int lineNumberNameIndex =
1904                                 constantPool.literalIndex(AttributeNamesConstants.LineNumberTableName);
1905                         localContents[localContentsOffset++] = (byte) (lineNumberNameIndex >> 8);
1906                         localContents[localContentsOffset++] = (byte) lineNumberNameIndex;
1907                         localContents[localContentsOffset++] = 0;
1908                         localContents[localContentsOffset++] = 0;
1909                         localContents[localContentsOffset++] = 0;
1910                         localContents[localContentsOffset++] = 6;
1911                         localContents[localContentsOffset++] = 0;
1912                         localContents[localContentsOffset++] = 1;
1913                         // first entry at pc = 0
1914                         localContents[localContentsOffset++] = 0;
1915                         localContents[localContentsOffset++] = 0;
1916                         localContents[localContentsOffset++] = (byte) (problemLine >> 8);
1917                         localContents[localContentsOffset++] = (byte) problemLine;
1918                         // now we change the size of the line number attribute
1919                         attributeNumber++;
1920                 }
1921                 // then we do the local variable attribute
1922                 if (codeStream.generateLocalVariableTableAttributes) {
1923                         int localVariableNameIndex =
1924                                 constantPool.literalIndex(AttributeNamesConstants.LocalVariableTableName);
1925                         if (localContentsOffset + 8 >= (contentsLength = localContents.length)) {
1926                                 System.arraycopy(
1927                                         contents,
1928                                         0,
1929                                         (localContents = contents = new byte[contentsLength + INCREMENT_SIZE]),
1930                                         0,
1931                                         contentsLength);
1932                         }
1933                         localContents[localContentsOffset++] = (byte) (localVariableNameIndex >> 8);
1934                         localContents[localContentsOffset++] = (byte) localVariableNameIndex;
1935                         localContents[localContentsOffset++] = 0;
1936                         localContents[localContentsOffset++] = 0;
1937                         localContents[localContentsOffset++] = 0;
1938                         localContents[localContentsOffset++] = 2;
1939                         localContents[localContentsOffset++] = 0;
1940                         localContents[localContentsOffset++] = 0;
1941                         attributeNumber++;
1942                 }
1943                 // update the number of attributes
1944                 // ensure first that there is enough space available inside the contents array
1945                 if (codeAttributeAttributeOffset + 2
1946                         >= (contentsLength = localContents.length)) {
1947                         System.arraycopy(
1948                                 contents,
1949                                 0,
1950                                 (localContents = contents = new byte[contentsLength + INCREMENT_SIZE]),
1951                                 0,
1952                                 contentsLength);
1953                 }
1954                 localContents[codeAttributeAttributeOffset++] = (byte) (attributeNumber >> 8);
1955                 localContents[codeAttributeAttributeOffset] = (byte) attributeNumber;
1956                 // update the attribute length
1957                 int codeAttributeLength = localContentsOffset - (codeAttributeOffset + 6);
1958                 localContents[codeAttributeOffset + 2] = (byte) (codeAttributeLength >> 24);
1959                 localContents[codeAttributeOffset + 3] = (byte) (codeAttributeLength >> 16);
1960                 localContents[codeAttributeOffset + 4] = (byte) (codeAttributeLength >> 8);
1961                 localContents[codeAttributeOffset + 5] = (byte) codeAttributeLength;
1962                 contentsOffset = localContentsOffset;
1963         }
1964
1965         /**
1966          * INTERNAL USE-ONLY
1967          * That method completes the creation of the code attribute by setting
1968          * - the attribute_length
1969          * - max_stack
1970          * - max_locals
1971          * - code_length
1972          * - exception table
1973          * - and debug attributes if necessary.
1974          *
1975          * @param codeStream org.eclipse.jdt.internal.compiler.codegen.CodeStream
1976          * @param codeAttributeOffset <CODE>int</CODE>
1977          * @param exceptionHandler int[]
1978          */
1979         public void completeCodeAttributeForProblemMethod(
1980                 AbstractMethodDeclaration method,
1981                 MethodBinding binding,
1982                 int codeAttributeOffset,
1983                 int[] exceptionHandler,
1984                 int[] startLineIndexes) {
1985                 // reinitialize the localContents with the byte modified by the code stream
1986                 byte[] localContents = contents = codeStream.bCodeStream;
1987                 int localContentsOffset = codeStream.classFileOffset;
1988                 // codeAttributeOffset is the position inside localContents byte array before we started to write// any information about the codeAttribute// That means that to write the attribute_length you need to offset by 2 the value of codeAttributeOffset// to get the right position, 6 for the max_stack etc...
1989                 int max_stack = codeStream.stackMax;
1990                 localContents[codeAttributeOffset + 6] = (byte) (max_stack >> 8);
1991                 localContents[codeAttributeOffset + 7] = (byte) max_stack;
1992                 int max_locals = codeStream.maxLocals;
1993                 localContents[codeAttributeOffset + 8] = (byte) (max_locals >> 8);
1994                 localContents[codeAttributeOffset + 9] = (byte) max_locals;
1995                 int code_length = codeStream.position;
1996                 localContents[codeAttributeOffset + 10] = (byte) (code_length >> 24);
1997                 localContents[codeAttributeOffset + 11] = (byte) (code_length >> 16);
1998                 localContents[codeAttributeOffset + 12] = (byte) (code_length >> 8);
1999                 localContents[codeAttributeOffset + 13] = (byte) code_length;
2000                 // write the exception table
2001                 int contentsLength;
2002                 if (localContentsOffset + 50 >= (contentsLength = localContents.length)) {
2003                         System.arraycopy(
2004                                 contents,
2005                                 0,
2006                                 (localContents = contents = new byte[contentsLength + INCREMENT_SIZE]),
2007                                 0,
2008                                 contentsLength);
2009                 }
2010                 localContents[localContentsOffset++] = 0;
2011                 localContents[localContentsOffset++] = 1;
2012                 int start = exceptionHandler[0];
2013                 localContents[localContentsOffset++] = (byte) (start >> 8);
2014                 localContents[localContentsOffset++] = (byte) start;
2015                 int end = exceptionHandler[1];
2016                 localContents[localContentsOffset++] = (byte) (end >> 8);
2017                 localContents[localContentsOffset++] = (byte) end;
2018                 int handlerPC = exceptionHandler[2];
2019                 localContents[localContentsOffset++] = (byte) (handlerPC >> 8);
2020                 localContents[localContentsOffset++] = (byte) handlerPC;
2021                 int nameIndex = constantPool.literalIndexForJavaLangException();
2022                 localContents[localContentsOffset++] = (byte) (nameIndex >> 8);
2023                 localContents[localContentsOffset++] = (byte) nameIndex; // debug attributes
2024                 int codeAttributeAttributeOffset = localContentsOffset;
2025                 int attributeNumber = 0; // leave two bytes for the attribute_length
2026                 localContentsOffset += 2; // first we handle the linenumber attribute
2027
2028                 if (codeStream.generateLineNumberAttributes) {
2029                         /* Create and add the line number attribute (used for debugging)
2030                             * Build the pairs of:
2031                             * (bytecodePC lineNumber)
2032                             * according to the table of start line indexes and the pcToSourceMap table
2033                             * contained into the codestream
2034                             */
2035                         int lineNumberNameIndex =
2036                                 constantPool.literalIndex(AttributeNamesConstants.LineNumberTableName);
2037                         localContents[localContentsOffset++] = (byte) (lineNumberNameIndex >> 8);
2038                         localContents[localContentsOffset++] = (byte) lineNumberNameIndex;
2039                         localContents[localContentsOffset++] = 0;
2040                         localContents[localContentsOffset++] = 0;
2041                         localContents[localContentsOffset++] = 0;
2042                         localContents[localContentsOffset++] = 6;
2043                         localContents[localContentsOffset++] = 0;
2044                         localContents[localContentsOffset++] = 1;
2045                         if (problemLine == 0) {
2046                                 problemLine = searchLineNumber(startLineIndexes, binding.sourceStart());
2047                         }
2048                         // first entry at pc = 0
2049                         localContents[localContentsOffset++] = 0;
2050                         localContents[localContentsOffset++] = 0;
2051                         localContents[localContentsOffset++] = (byte) (problemLine >> 8);
2052                         localContents[localContentsOffset++] = (byte) problemLine;
2053                         // now we change the size of the line number attribute
2054                         attributeNumber++;
2055                 }
2056                 // then we do the local variable attribute
2057                 if (codeStream.generateLocalVariableTableAttributes) {
2058                         // compute the resolved position for the arguments of the method
2059                         int argSize;
2060                         int localVariableTableOffset = localContentsOffset;
2061                         int numberOfEntries = 0;
2062                         //              codeAttribute.addLocalVariableTableAttribute(this);
2063                         int localVariableNameIndex =
2064                                 constantPool.literalIndex(AttributeNamesConstants.LocalVariableTableName);
2065                         if (localContentsOffset + 8 >= (contentsLength = localContents.length)) {
2066                                 System.arraycopy(
2067                                         contents,
2068                                         0,
2069                                         (localContents = contents = new byte[contentsLength + INCREMENT_SIZE]),
2070                                         0,
2071                                         contentsLength);
2072                         }
2073                         localContents[localContentsOffset++] = (byte) (localVariableNameIndex >> 8);
2074                         localContents[localContentsOffset++] = (byte) localVariableNameIndex;
2075                         localContentsOffset += 6;
2076                         // leave space for attribute_length and local_variable_table_length
2077                         int descriptorIndex;
2078                         if (!codeStream.methodDeclaration.isStatic()) {
2079                                 numberOfEntries++;
2080                                 if (localContentsOffset + 10 >= (contentsLength = localContents.length)) {
2081                                         System.arraycopy(
2082                                                 contents,
2083                                                 0,
2084                                                 (localContents = contents = new byte[contentsLength + INCREMENT_SIZE]),
2085                                                 0,
2086                                                 contentsLength);
2087                                 }
2088                                 localContents[localContentsOffset++] = 0;
2089                                 localContents[localContentsOffset++] = 0;
2090                                 localContents[localContentsOffset++] = (byte) (code_length >> 8);
2091                                 localContents[localContentsOffset++] = (byte) code_length;
2092                                 nameIndex = constantPool.literalIndex(QualifiedNamesConstants.This);
2093                                 localContents[localContentsOffset++] = (byte) (nameIndex >> 8);
2094                                 localContents[localContentsOffset++] = (byte) nameIndex;
2095                                 descriptorIndex =
2096                                         constantPool.literalIndex(
2097                                                 codeStream.methodDeclaration.binding.declaringClass.signature());
2098                                 localContents[localContentsOffset++] = (byte) (descriptorIndex >> 8);
2099                                 localContents[localContentsOffset++] = (byte) descriptorIndex;
2100                                 // the resolved position for this is always 0
2101                                 localContents[localContentsOffset++] = 0;
2102                                 localContents[localContentsOffset++] = 0;
2103                         }
2104                         if (binding.isConstructor()) {
2105                                 ReferenceBinding declaringClass = binding.declaringClass;
2106                                 if (declaringClass.isNestedType()) {
2107                                         NestedTypeBinding methodDeclaringClass = (NestedTypeBinding) declaringClass;
2108                                         argSize = methodDeclaringClass.syntheticArgumentsOffset;
2109                                         SyntheticArgumentBinding[] syntheticArguments;
2110                                         if ((syntheticArguments = methodDeclaringClass.syntheticEnclosingInstances())
2111                                                 != null) {
2112                                                 for (int i = 0, max = syntheticArguments.length; i < max; i++) {
2113                                                         LocalVariableBinding localVariable = syntheticArguments[i];
2114                                                         if (localContentsOffset + 10 >= (contentsLength = localContents.length)) {
2115                                                                 System.arraycopy(
2116                                                                         contents,
2117                                                                         0,
2118                                                                         (localContents = contents = new byte[contentsLength + INCREMENT_SIZE]),
2119                                                                         0,
2120                                                                         contentsLength);
2121                                                         }
2122                                                         // now we can safely add the local entry
2123                                                         numberOfEntries++;
2124                                                         localContents[localContentsOffset++] = 0;
2125                                                         localContents[localContentsOffset++] = 0;
2126                                                         localContents[localContentsOffset++] = (byte) (code_length >> 8);
2127                                                         localContents[localContentsOffset++] = (byte) code_length;
2128                                                         nameIndex = constantPool.literalIndex(localVariable.name);
2129                                                         localContents[localContentsOffset++] = (byte) (nameIndex >> 8);
2130                                                         localContents[localContentsOffset++] = (byte) nameIndex;
2131                                                         descriptorIndex = constantPool.literalIndex(localVariable.type.signature());
2132                                                         localContents[localContentsOffset++] = (byte) (descriptorIndex >> 8);
2133                                                         localContents[localContentsOffset++] = (byte) descriptorIndex;
2134                                                         int resolvedPosition = localVariable.resolvedPosition;
2135                                                         localContents[localContentsOffset++] = (byte) (resolvedPosition >> 8);
2136                                                         localContents[localContentsOffset++] = (byte) resolvedPosition;
2137                                                 }
2138                                         }
2139                                 } else {
2140                                         argSize = 1;
2141                                 }
2142                         } else {
2143                                 argSize = binding.isStatic() ? 0 : 1;
2144                         }
2145                         if (method.binding != null) {
2146                                 TypeBinding[] parameters = method.binding.parameters;
2147                                 Argument[] arguments = method.arguments;
2148                                 if ((parameters != null) && (arguments != null)) {
2149                                         for (int i = 0, max = parameters.length; i < max; i++) {
2150                                                 TypeBinding argumentBinding = parameters[i];
2151                                                 if (localContentsOffset + 10 >= (contentsLength = localContents.length)) {
2152                                                         System.arraycopy(
2153                                                                 contents,
2154                                                                 0,
2155                                                                 (localContents = contents = new byte[contentsLength + INCREMENT_SIZE]),
2156                                                                 0,
2157                                                                 contentsLength);
2158                                                 }
2159                                                 // now we can safely add the local entry
2160                                                 numberOfEntries++;
2161                                                 localContents[localContentsOffset++] = 0;
2162                                                 localContents[localContentsOffset++] = 0;
2163                                                 localContents[localContentsOffset++] = (byte) (code_length >> 8);
2164                                                 localContents[localContentsOffset++] = (byte) code_length;
2165                                                 nameIndex = constantPool.literalIndex(arguments[i].name);
2166                                                 localContents[localContentsOffset++] = (byte) (nameIndex >> 8);
2167                                                 localContents[localContentsOffset++] = (byte) nameIndex;
2168                                                 descriptorIndex = constantPool.literalIndex(argumentBinding.signature());
2169                                                 localContents[localContentsOffset++] = (byte) (descriptorIndex >> 8);
2170                                                 localContents[localContentsOffset++] = (byte) descriptorIndex;
2171                                                 int resolvedPosition = argSize;
2172                                                 if ((argumentBinding == TypeBinding.LongBinding)
2173                                                         || (argumentBinding == TypeBinding.DoubleBinding))
2174                                                         argSize += 2;
2175                                                 else
2176                                                         argSize++;
2177                                                 localContents[localContentsOffset++] = (byte) (resolvedPosition >> 8);
2178                                                 localContents[localContentsOffset++] = (byte) resolvedPosition;
2179                                         }
2180                                 }
2181                         }
2182                         int value = numberOfEntries * 10 + 2;
2183                         localVariableTableOffset += 2;
2184                         localContents[localVariableTableOffset++] = (byte) (value >> 24);
2185                         localContents[localVariableTableOffset++] = (byte) (value >> 16);
2186                         localContents[localVariableTableOffset++] = (byte) (value >> 8);
2187                         localContents[localVariableTableOffset++] = (byte) value;
2188                         localContents[localVariableTableOffset++] = (byte) (numberOfEntries >> 8);
2189                         localContents[localVariableTableOffset] = (byte) numberOfEntries;
2190                         attributeNumber++;
2191                 }
2192                 // update the number of attributes// ensure first that there is enough space available inside the localContents array
2193                 if (codeAttributeAttributeOffset + 2
2194                         >= (contentsLength = localContents.length)) {
2195                         System.arraycopy(
2196                                 contents,
2197                                 0,
2198                                 (localContents = contents = new byte[contentsLength + INCREMENT_SIZE]),
2199                                 0,
2200                                 contentsLength);
2201                 }
2202                 localContents[codeAttributeAttributeOffset++] = (byte) (attributeNumber >> 8);
2203                 localContents[codeAttributeAttributeOffset] = (byte) attributeNumber;
2204                 // update the attribute length
2205                 int codeAttributeLength = localContentsOffset - (codeAttributeOffset + 6);
2206                 localContents[codeAttributeOffset + 2] = (byte) (codeAttributeLength >> 24);
2207                 localContents[codeAttributeOffset + 3] = (byte) (codeAttributeLength >> 16);
2208                 localContents[codeAttributeOffset + 4] = (byte) (codeAttributeLength >> 8);
2209                 localContents[codeAttributeOffset + 5] = (byte) codeAttributeLength;
2210                 contentsOffset = localContentsOffset;
2211         }
2212
2213         /**
2214          * INTERNAL USE-ONLY
2215          * That method completes the creation of the code attribute by setting
2216          * - the attribute_length
2217          * - max_stack
2218          * - max_locals
2219          * - code_length
2220          * - exception table
2221          * - and debug attributes if necessary.
2222          *
2223          * @param binding org.eclipse.jdt.internal.compiler.lookup.SyntheticAccessMethodBinding
2224          * @param codeStream org.eclipse.jdt.internal.compiler.codegen.CodeStream
2225          * @param codeAttributeOffset <CODE>int</CODE>
2226          */
2227         public void completeCodeAttributeForSyntheticAccessMethod(
2228                 SyntheticAccessMethodBinding binding,
2229                 int codeAttributeOffset,
2230                 int[] startLineIndexes) {
2231                 // reinitialize the contents with the byte modified by the code stream
2232                 contents = codeStream.bCodeStream;
2233                 int localContentsOffset = codeStream.classFileOffset;
2234                 // codeAttributeOffset is the position inside contents byte array before we started to write
2235                 // any information about the codeAttribute
2236                 // That means that to write the attribute_length you need to offset by 2 the value of codeAttributeOffset
2237                 // to get the right position, 6 for the max_stack etc...
2238                 int max_stack = codeStream.stackMax;
2239                 contents[codeAttributeOffset + 6] = (byte) (max_stack >> 8);
2240                 contents[codeAttributeOffset + 7] = (byte) max_stack;
2241                 int max_locals = codeStream.maxLocals;
2242                 contents[codeAttributeOffset + 8] = (byte) (max_locals >> 8);
2243                 contents[codeAttributeOffset + 9] = (byte) max_locals;
2244                 int code_length = codeStream.position;
2245                 contents[codeAttributeOffset + 10] = (byte) (code_length >> 24);
2246                 contents[codeAttributeOffset + 11] = (byte) (code_length >> 16);
2247                 contents[codeAttributeOffset + 12] = (byte) (code_length >> 8);
2248                 contents[codeAttributeOffset + 13] = (byte) code_length;
2249                 int contentsLength;
2250                 if ((localContentsOffset + 40) >= (contentsLength = contents.length)) {
2251                         System.arraycopy(
2252                                 contents,
2253                                 0,
2254                                 (contents = new byte[contentsLength + INCREMENT_SIZE]),
2255                                 0,
2256                                 contentsLength);
2257                 }
2258                 // there is no exception table, so we need to offset by 2 the current offset and move
2259                 // on the attribute generation
2260                 localContentsOffset += 2;
2261                 // debug attributes
2262                 int codeAttributeAttributeOffset = localContentsOffset;
2263                 int attributeNumber = 0;
2264                 // leave two bytes for the attribute_length
2265                 localContentsOffset += 2;
2266
2267                 // first we handle the linenumber attribute
2268                 if (codeStream.generateLineNumberAttributes) {
2269                         int index = 0;
2270                         int lineNumberNameIndex =
2271                                 constantPool.literalIndex(AttributeNamesConstants.LineNumberTableName);
2272                         contents[localContentsOffset++] = (byte) (lineNumberNameIndex >> 8);
2273                         contents[localContentsOffset++] = (byte) lineNumberNameIndex;
2274                         int lineNumberTableOffset = localContentsOffset;
2275                         localContentsOffset += 6;
2276                         // leave space for attribute_length and line_number_table_length
2277                         // Seems like do would be better, but this preserves the existing behavior.
2278                         index = searchLineNumber(startLineIndexes, binding.sourceStart);
2279                         contents[localContentsOffset++] = 0;
2280                         contents[localContentsOffset++] = 0;
2281                         contents[localContentsOffset++] = (byte) (index >> 8);
2282                         contents[localContentsOffset++] = (byte) index;
2283                         // now we change the size of the line number attribute
2284                         contents[lineNumberTableOffset++] = 0;
2285                         contents[lineNumberTableOffset++] = 0;
2286                         contents[lineNumberTableOffset++] = 0;
2287                         contents[lineNumberTableOffset++] = 6;
2288                         contents[lineNumberTableOffset++] = 0;
2289                         contents[lineNumberTableOffset++] = 1;
2290                         attributeNumber++;
2291                 }
2292                 // then we do the local variable attribute
2293                 if (codeStream.generateLocalVariableTableAttributes) {
2294                         int localVariableTableOffset = localContentsOffset;
2295                         int numberOfEntries = 0;
2296                         int localVariableNameIndex =
2297                                 constantPool.literalIndex(AttributeNamesConstants.LocalVariableTableName);
2298                         if (localContentsOffset + 8 > (contentsLength = contents.length)) {
2299                                 System.arraycopy(
2300                                         contents,
2301                                         0,
2302                                         (contents = new byte[contentsLength + INCREMENT_SIZE]),
2303                                         0,
2304                                         contentsLength);
2305                         }
2306                         contents[localContentsOffset++] = (byte) (localVariableNameIndex >> 8);
2307                         contents[localContentsOffset++] = (byte) localVariableNameIndex;
2308                         localContentsOffset += 6;
2309                         // leave space for attribute_length and local_variable_table_length
2310                         int nameIndex;
2311                         int descriptorIndex;
2312                         for (int i = 0; i < codeStream.allLocalsCounter; i++) {
2313                                 LocalVariableBinding localVariable = codeStream.locals[i];
2314                                 for (int j = 0; j < localVariable.initializationCount; j++) {
2315                                         int startPC = localVariable.initializationPCs[j << 1];
2316                                         int endPC = localVariable.initializationPCs[(j << 1) + 1];
2317                                         if (startPC != endPC) { // only entries for non zero length
2318                                                 if (endPC == -1) {
2319                                                         localVariable.declaringScope.problemReporter().abortDueToInternalError(
2320                                                                 Util.bind("abort.invalidAttribute" , new String(localVariable.name)), //$NON-NLS-1$
2321                                                                 (AstNode) localVariable.declaringScope.methodScope().referenceContext);
2322                                                 }
2323                                                 if (localContentsOffset + 10 > (contentsLength = contents.length)) {
2324                                                         System.arraycopy(
2325                                                                 contents,
2326                                                                 0,
2327                                                                 (contents = new byte[contentsLength + INCREMENT_SIZE]),
2328                                                                 0,
2329                                                                 contentsLength);
2330                                                 }
2331                                                 // now we can safely add the local entry
2332                                                 numberOfEntries++;
2333                                                 contents[localContentsOffset++] = (byte) (startPC >> 8);
2334                                                 contents[localContentsOffset++] = (byte) startPC;
2335                                                 int length = endPC - startPC;
2336                                                 contents[localContentsOffset++] = (byte) (length >> 8);
2337                                                 contents[localContentsOffset++] = (byte) length;
2338                                                 nameIndex = constantPool.literalIndex(localVariable.name);
2339                                                 contents[localContentsOffset++] = (byte) (nameIndex >> 8);
2340                                                 contents[localContentsOffset++] = (byte) nameIndex;
2341                                                 descriptorIndex = constantPool.literalIndex(localVariable.type.signature());
2342                                                 contents[localContentsOffset++] = (byte) (descriptorIndex >> 8);
2343                                                 contents[localContentsOffset++] = (byte) descriptorIndex;
2344                                                 int resolvedPosition = localVariable.resolvedPosition;
2345                                                 contents[localContentsOffset++] = (byte) (resolvedPosition >> 8);
2346                                                 contents[localContentsOffset++] = (byte) resolvedPosition;
2347                                         }
2348                                 }
2349                         }
2350                         int value = numberOfEntries * 10 + 2;
2351                         localVariableTableOffset += 2;
2352                         contents[localVariableTableOffset++] = (byte) (value >> 24);
2353                         contents[localVariableTableOffset++] = (byte) (value >> 16);
2354                         contents[localVariableTableOffset++] = (byte) (value >> 8);
2355                         contents[localVariableTableOffset++] = (byte) value;
2356                         contents[localVariableTableOffset++] = (byte) (numberOfEntries >> 8);
2357                         contents[localVariableTableOffset] = (byte) numberOfEntries;
2358                         attributeNumber++;
2359                 }
2360                 // update the number of attributes
2361                 // ensure first that there is enough space available inside the contents array
2362                 if (codeAttributeAttributeOffset + 2 >= (contentsLength = contents.length)) {
2363                         System.arraycopy(
2364                                 contents,
2365                                 0,
2366                                 (contents = new byte[contentsLength + INCREMENT_SIZE]),
2367                                 0,
2368                                 contentsLength);
2369                 }
2370                 contents[codeAttributeAttributeOffset++] = (byte) (attributeNumber >> 8);
2371                 contents[codeAttributeAttributeOffset] = (byte) attributeNumber;
2372
2373                 // update the attribute length
2374                 int codeAttributeLength = localContentsOffset - (codeAttributeOffset + 6);
2375                 contents[codeAttributeOffset + 2] = (byte) (codeAttributeLength >> 24);
2376                 contents[codeAttributeOffset + 3] = (byte) (codeAttributeLength >> 16);
2377                 contents[codeAttributeOffset + 4] = (byte) (codeAttributeLength >> 8);
2378                 contents[codeAttributeOffset + 5] = (byte) codeAttributeLength;
2379                 contentsOffset = localContentsOffset;
2380         }
2381
2382         /**
2383          * INTERNAL USE-ONLY
2384          * Complete the creation of a method info by setting up the number of attributes at the right offset.
2385          *
2386          * @param methodAttributeOffset <CODE>int</CODE>
2387          * @param attributeNumber <CODE>int</CODE>
2388          */
2389         public void completeMethodInfo(
2390                 int methodAttributeOffset,
2391                 int attributeNumber) {
2392                 // update the number of attributes
2393                 contents[methodAttributeOffset++] = (byte) (attributeNumber >> 8);
2394                 contents[methodAttributeOffset] = (byte) attributeNumber;
2395         }
2396
2397         /*
2398          * INTERNAL USE-ONLY
2399          * Innerclasses get their name computed as they are generated, since some may not
2400          * be actually outputed if sitting inside unreachable code.
2401          *
2402          * @param localType org.eclipse.jdt.internal.compiler.lookup.LocalTypeBinding
2403          */
2404         public char[] computeConstantPoolName(LocalTypeBinding localType) {
2405                 if (localType.constantPoolName() != null) {
2406                         return localType.constantPoolName();
2407                 }
2408                 // delegates to the outermost enclosing classfile, since it is the only one with a global vision of its innertypes.
2409                 if (enclosingClassFile != null) {
2410                         return this.outerMostEnclosingClassFile().computeConstantPoolName(localType);
2411                 }
2412                 if (nameUsage == null)
2413                         nameUsage = new HashtableOfType();
2414
2415                 // ensure there is not already such a local type name defined by the user
2416                 int index = 0;
2417                 char[] candidateName;
2418                 while(true) {
2419                         if (localType.isMemberType()){
2420                                 if (index == 0){
2421                                         candidateName = CharOperation.concat(
2422                                                 localType.enclosingType().constantPoolName(),
2423                                                 localType.sourceName,
2424                                                 '$');
2425                                 } else {
2426                                         // in case of collision, then member name gets extra $1 inserted
2427                                         // e.g. class X { { class L{} new X(){ class L{} } } }
2428                                         candidateName = CharOperation.concat(
2429                                                 localType.enclosingType().constantPoolName(),
2430                                                 '$',
2431                                                 String.valueOf(index).toCharArray(),
2432                                                 '$',
2433                                                 localType.sourceName);
2434                                 }
2435                         } else if (localType.isAnonymousType()){
2436                                         candidateName = CharOperation.concat(
2437                                                 referenceBinding.constantPoolName(),
2438                                                 String.valueOf(index+1).toCharArray(),
2439                                                 '$');
2440                         } else {
2441                                         candidateName = CharOperation.concat(
2442                                                 referenceBinding.constantPoolName(),
2443                                                 '$',
2444                                                 String.valueOf(index+1).toCharArray(),
2445                                                 '$',
2446                                                 localType.sourceName);
2447                         }
2448                         if (nameUsage.get(candidateName) != null) {
2449                                 index ++;
2450                         } else {
2451                                 nameUsage.put(candidateName, localType);
2452                                 break;
2453                         }
2454                 }
2455                 return candidateName;
2456         }
2457
2458         /**
2459          * INTERNAL USE-ONLY
2460          * Request the creation of a ClassFile compatible representation of a problematic type
2461          *
2462          * @param typeDeclaration org.eclipse.jdt.internal.compiler.ast.TypeDeclaration
2463          * @param unitResult org.eclipse.jdt.internal.compiler.CompilationUnitResult
2464          */
2465         public static void createProblemType(
2466                 TypeDeclaration typeDeclaration,
2467                 CompilationResult unitResult) {
2468                 SourceTypeBinding typeBinding = typeDeclaration.binding;
2469                 ClassFile classFile = new ClassFile(typeBinding, null, true);
2470
2471                 // inner attributes
2472                 if (typeBinding.isMemberType())
2473                         classFile.recordEnclosingTypeAttributes(typeBinding);
2474
2475                 // add its fields
2476                 FieldBinding[] fields = typeBinding.fields;
2477                 if ((fields != null) && (fields != NoFields)) {
2478                         for (int i = 0, max = fields.length; i < max; i++) {
2479                                 if (fields[i].constant == null) {
2480                                         FieldReference.getConstantFor(fields[i], false, null, null, 0);
2481                                 }
2482                         }
2483                         classFile.addFieldInfos();
2484                 } else {
2485                         // we have to set the number of fields to be equals to 0
2486                         classFile.contents[classFile.contentsOffset++] = 0;
2487                         classFile.contents[classFile.contentsOffset++] = 0;
2488                 }
2489                 // leave some space for the methodCount
2490                 classFile.setForMethodInfos();
2491                 // add its user defined methods
2492                 MethodBinding[] methods = typeBinding.methods;
2493                 AbstractMethodDeclaration[] methodDeclarations = typeDeclaration.methods;
2494                 int maxMethodDecl = methodDeclarations == null ? 0 : methodDeclarations.length;
2495                 int problemsLength;
2496                 IProblem[] problems = unitResult.getProblems();
2497                 if (problems == null) {
2498                         problems = new IProblem[0];
2499                 }
2500                 IProblem[] problemsCopy = new IProblem[problemsLength = problems.length];
2501                 System.arraycopy(problems, 0, problemsCopy, 0, problemsLength);
2502                 if (methods != null) {
2503                         if (typeBinding.isInterface()) {
2504                                 // we cannot create problem methods for an interface. So we have to generate a clinit
2505                                 // which should contain all the problem
2506                                 classFile.addProblemClinit(problemsCopy);
2507                                 for (int i = 0, max = methods.length; i < max; i++) {
2508                                         MethodBinding methodBinding;
2509                                         if ((methodBinding = methods[i]) != null) {
2510                                                 // find the corresponding method declaration
2511                                                 for (int j = 0; j < maxMethodDecl; j++) {
2512                                                         if ((methodDeclarations[j] != null)
2513                                                                 && (methodDeclarations[j].binding == methods[i])) {
2514                                                                 if (!methodBinding.isConstructor()) {
2515                                                                         classFile.addAbstractMethod(methodDeclarations[j], methodBinding);
2516                                                                 }
2517                                                                 break;
2518                                                         }
2519                                                 }
2520                                         }
2521                                 }
2522                         } else {
2523                                 for (int i = 0, max = methods.length; i < max; i++) {
2524                                         MethodBinding methodBinding;
2525                                         if ((methodBinding = methods[i]) != null) {
2526                                                 // find the corresponding method declaration
2527                                                 for (int j = 0; j < maxMethodDecl; j++) {
2528                                                         if ((methodDeclarations[j] != null)
2529                                                                 && (methodDeclarations[j].binding == methods[i])) {
2530                                                                 AbstractMethodDeclaration methodDecl;
2531                                                                 if ((methodDecl = methodDeclarations[j]).isConstructor()) {
2532                                                                         classFile.addProblemConstructor(methodDecl, methodBinding, problemsCopy);
2533                                                                 } else {
2534                                                                         classFile.addProblemMethod(methodDecl, methodBinding, problemsCopy);
2535                                                                 }
2536                                                                 break;
2537                                                         }
2538                                                 }
2539                                         }
2540                                 }
2541                         }
2542                         // add abstract methods
2543                         classFile.addDefaultAbstractMethods();
2544                 }
2545                 // propagate generation of (problem) member types
2546                 if (typeDeclaration.memberTypes != null) {
2547                         for (int i = 0, max = typeDeclaration.memberTypes.length; i < max; i++) {
2548                                 TypeDeclaration memberType = typeDeclaration.memberTypes[i];
2549                                 if (memberType.binding != null) {
2550                                         classFile.recordNestedMemberAttribute(memberType.binding);
2551                                         ClassFile.createProblemType(memberType, unitResult);
2552                                 }
2553                         }
2554                 }
2555                 classFile.addAttributes();
2556                 unitResult.record(typeBinding.constantPoolName(), classFile);
2557         }
2558
2559         /**
2560          * INTERNAL USE-ONLY
2561          * This methods returns a char[] representing the file name of the receiver
2562          *
2563          * @return char[]
2564          */
2565         public char[] fileName() {
2566                 return constantPool.UTF8Cache.returnKeyFor(1);
2567         }
2568
2569         /**
2570          * INTERNAL USE-ONLY
2571          * That method generates the header of a code attribute.
2572          * - the index inside the constant pool for the attribute name (i.e.&nbsp;Code)
2573          * - leave some space for attribute_length(4), max_stack(2), max_locals(2), code_length(4).
2574          */
2575         public void generateCodeAttributeHeader() {
2576                 int contentsLength;
2577                 if (contentsOffset + 20 >= (contentsLength = contents.length)) {
2578                         System.arraycopy(
2579                                 contents,
2580                                 0,
2581                                 (contents = new byte[contentsLength + INCREMENT_SIZE]),
2582                                 0,
2583                                 contentsLength);
2584                 }
2585                 int constantValueNameIndex =
2586                         constantPool.literalIndex(AttributeNamesConstants.CodeName);
2587                 contents[contentsOffset++] = (byte) (constantValueNameIndex >> 8);
2588                 contents[contentsOffset++] = (byte) constantValueNameIndex;
2589                 // leave space for attribute_length(4), max_stack(2), max_locals(2), code_length(4)
2590                 contentsOffset += 12;
2591         }
2592
2593         /**
2594          * INTERNAL USE-ONLY
2595          * That method generates the attributes of a code attribute.
2596          * They could be:
2597          * - an exception attribute for each try/catch found inside the method
2598          * - a deprecated attribute
2599          * - a synthetic attribute for synthetic access methods
2600          *
2601          * It returns the number of attributes created for the code attribute.
2602          *
2603          * @param methodBinding org.eclipse.jdt.internal.compiler.lookup.MethodBinding
2604          * @return <CODE>int</CODE>
2605          */
2606         public int generateMethodInfoAttribute(MethodBinding methodBinding) {
2607                 // leave two bytes for the attribute_number
2608                 contentsOffset += 2;
2609                 // now we can handle all the attribute for that method info:
2610                 // it could be:
2611                 // - a CodeAttribute
2612                 // - a ExceptionAttribute
2613                 // - a DeprecatedAttribute
2614                 // - a SyntheticAttribute
2615
2616                 // Exception attribute
2617                 ReferenceBinding[] thrownsExceptions;
2618                 int contentsLength;
2619                 int attributeNumber = 0;
2620                 if ((thrownsExceptions = methodBinding.thrownExceptions) != NoExceptions) {
2621                         // The method has a throw clause. So we need to add an exception attribute
2622                         // check that there is enough space to write all the bytes for the exception attribute
2623                         int length = thrownsExceptions.length;
2624                         if (contentsOffset + (8 + length * 2) >= (contentsLength = contents.length)) {
2625                                 System.arraycopy(
2626                                         contents,
2627                                         0,
2628                                         (contents =
2629                                                 new byte[contentsLength + Math.max(INCREMENT_SIZE, (8 + length * 2))]),
2630                                         0,
2631                                         contentsLength);
2632                         }
2633                         int exceptionNameIndex =
2634                                 constantPool.literalIndex(AttributeNamesConstants.ExceptionsName);
2635                         contents[contentsOffset++] = (byte) (exceptionNameIndex >> 8);
2636                         contents[contentsOffset++] = (byte) exceptionNameIndex;
2637                         // The attribute length = length * 2 + 2 in case of a exception attribute
2638                         int attributeLength = length * 2 + 2;
2639                         contents[contentsOffset++] = (byte) (attributeLength >> 24);
2640                         contents[contentsOffset++] = (byte) (attributeLength >> 16);
2641                         contents[contentsOffset++] = (byte) (attributeLength >> 8);
2642                         contents[contentsOffset++] = (byte) attributeLength;
2643                         contents[contentsOffset++] = (byte) (length >> 8);
2644                         contents[contentsOffset++] = (byte) length;
2645                         for (int i = 0; i < length; i++) {
2646                                 int exceptionIndex = constantPool.literalIndex(thrownsExceptions[i]);
2647                                 contents[contentsOffset++] = (byte) (exceptionIndex >> 8);
2648                                 contents[contentsOffset++] = (byte) exceptionIndex;
2649                         }
2650                         attributeNumber++;
2651                 }
2652                 // Deprecated attribute
2653                 // Check that there is enough space to write the deprecated attribute
2654                 if (contentsOffset + 6 >= (contentsLength = contents.length)) {
2655                         System.arraycopy(
2656                                 contents,
2657                                 0,
2658                                 (contents = new byte[contentsLength + INCREMENT_SIZE]),
2659                                 0,
2660                                 contentsLength);
2661                 }
2662                 if (methodBinding.isDeprecated()) {
2663                         int deprecatedAttributeNameIndex =
2664                                 constantPool.literalIndex(AttributeNamesConstants.DeprecatedName);
2665                         contents[contentsOffset++] = (byte) (deprecatedAttributeNameIndex >> 8);
2666                         contents[contentsOffset++] = (byte) deprecatedAttributeNameIndex;
2667                         // the length of a deprecated attribute is equals to 0
2668                         contents[contentsOffset++] = 0;
2669                         contents[contentsOffset++] = 0;
2670                         contents[contentsOffset++] = 0;
2671                         contents[contentsOffset++] = 0;
2672
2673                         attributeNumber++;
2674                 }
2675                 // Synthetic attribute
2676                 // Check that there is enough space to write the deprecated attribute
2677                 if (contentsOffset + 6 >= (contentsLength = contents.length)) {
2678                         System.arraycopy(
2679                                 contents,
2680                                 0,
2681                                 (contents = new byte[contentsLength + INCREMENT_SIZE]),
2682                                 0,
2683                                 contentsLength);
2684                 }
2685                 if (methodBinding.isSynthetic()) {
2686                         int syntheticAttributeNameIndex =
2687                                 constantPool.literalIndex(AttributeNamesConstants.SyntheticName);
2688                         contents[contentsOffset++] = (byte) (syntheticAttributeNameIndex >> 8);
2689                         contents[contentsOffset++] = (byte) syntheticAttributeNameIndex;
2690                         // the length of a synthetic attribute is equals to 0
2691                         contents[contentsOffset++] = 0;
2692                         contents[contentsOffset++] = 0;
2693                         contents[contentsOffset++] = 0;
2694                         contents[contentsOffset++] = 0;
2695
2696                         attributeNumber++;
2697                 }
2698                 return attributeNumber;
2699         }
2700
2701         /**
2702          * INTERNAL USE-ONLY
2703          * That method generates the header of a method info:
2704          * The header consists in:
2705          * - the access flags
2706          * - the name index of the method name inside the constant pool
2707          * - the descriptor index of the signature of the method inside the constant pool.
2708          *
2709          * @param methodBinding org.eclipse.jdt.internal.compiler.lookup.MethodBinding
2710          */
2711         public void generateMethodInfoHeader(MethodBinding methodBinding) {
2712                 // check that there is enough space to write all the bytes for the method info corresponding
2713                 // to the @methodBinding
2714                 int contentsLength;
2715                 methodCount++; // add one more method
2716                 if (contentsOffset + 10 >= (contentsLength = contents.length)) {
2717                         System.arraycopy(
2718                                 contents,
2719                                 0,
2720                                 (contents = new byte[contentsLength + INCREMENT_SIZE]),
2721                                 0,
2722                                 contentsLength);
2723                 }
2724                 int accessFlags = methodBinding.getAccessFlags();
2725                 if (methodBinding.isRequiredToClearPrivateModifier()) {
2726                         accessFlags &= ~AccPrivate;
2727                 }
2728                 contents[contentsOffset++] = (byte) (accessFlags >> 8);
2729                 contents[contentsOffset++] = (byte) accessFlags;
2730                 int nameIndex = constantPool.literalIndex(methodBinding.selector);
2731                 contents[contentsOffset++] = (byte) (nameIndex >> 8);
2732                 contents[contentsOffset++] = (byte) nameIndex;
2733                 int descriptorIndex = constantPool.literalIndex(methodBinding.signature());
2734                 contents[contentsOffset++] = (byte) (descriptorIndex >> 8);
2735                 contents[contentsOffset++] = (byte) descriptorIndex;
2736         }
2737
2738         /**
2739          * INTERNAL USE-ONLY
2740          * That method generates the method info header of a clinit:
2741          * The header consists in:
2742          * - the access flags (always default access + static)
2743          * - the name index of the method name (always <clinit>) inside the constant pool
2744          * - the descriptor index of the signature (always ()V) of the method inside the constant pool.
2745          *
2746          * @param methodBinding org.eclipse.jdt.internal.compiler.lookup.MethodBinding
2747          */
2748         public void generateMethodInfoHeaderForClinit() {
2749                 // check that there is enough space to write all the bytes for the method info corresponding
2750                 // to the @methodBinding
2751                 int contentsLength;
2752                 methodCount++; // add one more method
2753                 if (contentsOffset + 10 >= (contentsLength = contents.length)) {
2754                         System.arraycopy(
2755                                 contents,
2756                                 0,
2757                                 (contents = new byte[contentsLength + INCREMENT_SIZE]),
2758                                 0,
2759                                 contentsLength);
2760                 }
2761                 contents[contentsOffset++] = (byte) ((AccDefault | AccStatic) >> 8);
2762                 contents[contentsOffset++] = (byte) (AccDefault | AccStatic);
2763                 int nameIndex = constantPool.literalIndex(QualifiedNamesConstants.Clinit);
2764                 contents[contentsOffset++] = (byte) (nameIndex >> 8);
2765                 contents[contentsOffset++] = (byte) nameIndex;
2766                 int descriptorIndex =
2767                         constantPool.literalIndex(QualifiedNamesConstants.ClinitSignature);
2768                 contents[contentsOffset++] = (byte) (descriptorIndex >> 8);
2769                 contents[contentsOffset++] = (byte) descriptorIndex;
2770                 // We know that we won't get more than 1 attribute: the code attribute
2771                 contents[contentsOffset++] = 0;
2772                 contents[contentsOffset++] = 1;
2773         }
2774
2775         /**
2776          * EXTERNAL API
2777          * Answer the actual bytes of the class file
2778          *
2779          * This method encodes the receiver structure into a byte array which is the content of the classfile.
2780          * Returns the byte array that represents the encoded structure of the receiver.
2781          *
2782          * @return byte[]
2783          */
2784         public byte[] getBytes() {
2785                 byte[] fullContents = new byte[headerOffset + contentsOffset];
2786                 System.arraycopy(header, 0, fullContents, 0, headerOffset);
2787                 System.arraycopy(contents, 0, fullContents, headerOffset, contentsOffset);
2788                 return fullContents;
2789         }
2790
2791         /**
2792          * EXTERNAL API
2793          * Answer the compound name of the class file.
2794          * @return char[][]
2795          * e.g. {{java}, {util}, {Hashtable}}.
2796          */
2797         public char[][] getCompoundName() {
2798                 return CharOperation.splitOn('/', fileName());
2799         }
2800
2801         /**
2802          * INTERNAL USE-ONLY
2803          * Returns the most enclosing classfile of the receiver. This is used know to store the constant pool name
2804          * for all inner types of the receiver.
2805          * @return org.eclipse.jdt.internal.compiler.codegen.ClassFile
2806          */
2807         public ClassFile outerMostEnclosingClassFile() {
2808                 ClassFile current = this;
2809                 while (current.enclosingClassFile != null)
2810                         current = current.enclosingClassFile;
2811                 return current;
2812         }
2813
2814         /**
2815          * INTERNAL USE-ONLY
2816          * This is used to store a new inner class. It checks that the binding @binding doesn't already exist inside the
2817          * collection of inner classes. Add all the necessary classes in the right order to fit to the specifications.
2818          *
2819          * @param binding org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding
2820          */
2821         public void recordEnclosingTypeAttributes(ReferenceBinding binding) {
2822                 // add all the enclosing types
2823                 ReferenceBinding enclosingType = referenceBinding.enclosingType();
2824                 int depth = 0;
2825                 while (enclosingType != null) {
2826                         depth++;
2827                         enclosingType = enclosingType.enclosingType();
2828                 }
2829                 enclosingType = referenceBinding;
2830                 ReferenceBinding enclosingTypes[];
2831                 if (depth >= 2) {
2832                         enclosingTypes = new ReferenceBinding[depth];
2833                         for (int i = depth - 1; i >= 0; i--) {
2834                                 enclosingTypes[i] = enclosingType;
2835                                 enclosingType = enclosingType.enclosingType();
2836                         }
2837                         for (int i = 0; i < depth; i++) {
2838                                 addInnerClasses(enclosingTypes[i]);
2839                         }
2840                 } else {
2841                         addInnerClasses(referenceBinding);
2842                 }
2843         }
2844
2845         /**
2846          * INTERNAL USE-ONLY
2847          * This is used to store a new inner class. It checks that the binding @binding doesn't already exist inside the
2848          * collection of inner classes. Add all the necessary classes in the right order to fit to the specifications.
2849          *
2850          * @param binding org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding
2851          */
2852         public void recordNestedLocalAttribute(ReferenceBinding binding) {
2853                 // add all the enclosing types
2854                 ReferenceBinding enclosingType = referenceBinding.enclosingType();
2855                 int depth = 0;
2856                 while (enclosingType != null) {
2857                         depth++;
2858                         enclosingType = enclosingType.enclosingType();
2859                 }
2860                 enclosingType = referenceBinding;
2861                 ReferenceBinding enclosingTypes[];
2862                 if (depth >= 2) {
2863                         enclosingTypes = new ReferenceBinding[depth];
2864                         for (int i = depth - 1; i >= 0; i--) {
2865                                 enclosingTypes[i] = enclosingType;
2866                                 enclosingType = enclosingType.enclosingType();
2867                         }
2868                         for (int i = 0; i < depth; i++)
2869                                 addInnerClasses(enclosingTypes[i]);
2870                 } else {
2871                         addInnerClasses(binding);
2872                 }
2873         }
2874
2875         /**
2876          * INTERNAL USE-ONLY
2877          * This is used to store a new inner class. It checks that the binding @binding doesn't already exist inside the
2878          * collection of inner classes. Add all the necessary classes in the right order to fit to the specifications.
2879          *
2880          * @param binding org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding
2881          */
2882         public void recordNestedMemberAttribute(ReferenceBinding binding) {
2883                 addInnerClasses(binding);
2884         }
2885
2886         /**
2887          * INTERNAL USE-ONLY
2888          * Search the line number corresponding to a specific position
2889          *
2890          * @param methodBinding org.eclipse.jdt.internal.compiler.nameloopkup.SyntheticAccessMethodBinding
2891          */
2892         public static final int searchLineNumber(
2893                 int[] startLineIndexes,
2894                 int position) {
2895                 // this code is completely useless, but it is the same implementation than
2896                 // org.eclipse.jdt.internal.compiler.problem.ProblemHandler.searchLineNumber(int[], int)
2897                 // if (startLineIndexes == null)
2898                 //      return 1;
2899                 int length = startLineIndexes.length;
2900                 if (length == 0)
2901                         return 1;
2902                 int g = 0, d = length - 1;
2903                 int m = 0;
2904                 while (g <= d) {
2905                         m = (g + d) / 2;
2906                         if (position < startLineIndexes[m]) {
2907                                 d = m - 1;
2908                         } else
2909                                 if (position > startLineIndexes[m]) {
2910                                         g = m + 1;
2911                                 } else {
2912                                         return m + 1;
2913                                 }
2914                 }
2915                 if (position < startLineIndexes[m]) {
2916                         return m + 1;
2917                 }
2918                 return m + 2;
2919         }
2920
2921         /**
2922          * INTERNAL USE-ONLY
2923          * This methods leaves the space for method counts recording.
2924          */
2925         public void setForMethodInfos() {
2926                 // leave some space for the methodCount
2927                 methodCountOffset = contentsOffset;
2928                 contentsOffset += 2;
2929         }
2930
2931         /**
2932          * INTERNAL USE-ONLY
2933          * outputPath is formed like:
2934          *         c:\temp\ the last character is a file separator
2935          * relativeFileName is formed like:
2936          *     java\lang\String.class
2937          * @param generatePackagesStructure a flag to know if the packages structure has to be generated.
2938          * @param outputPath the output directory
2939          * @param relativeFileName java.lang.String
2940          * @param contents byte[]
2941          *
2942          */
2943         public static void writeToDisk(
2944                 boolean generatePackagesStructure,
2945                 String outputPath,
2946                 String relativeFileName,
2947                 byte[] contents)
2948                 throws IOException {
2949
2950                 BufferedOutputStream output = null;
2951                 if (generatePackagesStructure) {
2952                         output = new BufferedOutputStream(
2953                                 new FileOutputStream(
2954                                                 new File(buildAllDirectoriesInto(outputPath, relativeFileName))));
2955                 } else {
2956                         String fileName = null;
2957                         char fileSeparatorChar = File.separatorChar;
2958                         String fileSeparator = File.separator;
2959                         // First we ensure that the outputPath exists
2960                         outputPath = outputPath.replace('/', fileSeparatorChar);
2961                         // To be able to pass the mkdirs() method we need to remove the extra file separator at the end of the outDir name
2962                         int indexOfPackageSeparator = relativeFileName.lastIndexOf(fileSeparatorChar);
2963                         if (indexOfPackageSeparator == -1) {
2964                                 if (outputPath.endsWith(fileSeparator)) {
2965                                         fileName = outputPath + relativeFileName;
2966                                 } else {
2967                                         fileName = outputPath + fileSeparator + relativeFileName;
2968                                 }
2969                         } else {
2970                                 int length = relativeFileName.length();
2971                                 if (outputPath.endsWith(fileSeparator)) {
2972                                         fileName = outputPath + relativeFileName.substring(indexOfPackageSeparator + 1, length);
2973                                 } else {
2974                                         fileName = outputPath + fileSeparator + relativeFileName.substring(indexOfPackageSeparator + 1, length);
2975                                 }
2976                         }
2977                         output = new BufferedOutputStream(
2978                                 new FileOutputStream(
2979                                                 new File(fileName)));
2980                 }
2981                 try {
2982                         output.write(contents);
2983                 } finally {
2984                         output.flush();
2985                         output.close();
2986                 }
2987         }
2988 }