net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/codegen/ConstantPool.java

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2001, 2002 International Business Machines Corp. and others.
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Common Public License v0.5
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/cpl-v05.html
   7  *
   8  * Contributors:
   9  *     IBM Corporation - initial API and implementation
  10  ******************************************************************************/
  11 package net.sourceforge.phpdt.internal.compiler.codegen;
  12
  13 import net.sourceforge.phpdt.internal.compiler.ClassFile;
  14
  15 import net.sourceforge.phpdt.internal.compiler.classfmt.ClassFileConstants;
  16 import net.sourceforge.phpdt.internal.compiler.lookup.*;
  17 import net.sourceforge.phpdt.internal.compiler.util.*;
  18
  19 /**
  20  * This type is used to store all the constant pool entries.
  21  */
  22 public class ConstantPool implements ClassFileConstants, TypeIds {
  23         public static final int DOUBLE_INITIAL_SIZE = 5;
  24         public static final int FLOAT_INITIAL_SIZE = 3;
  25         public static final int INT_INITIAL_SIZE = 248;
  26         public static final int LONG_INITIAL_SIZE = 5;
  27         public static final int UTF8_INITIAL_SIZE = 778;
  28         public static final int STRING_INITIAL_SIZE = 761;
  29         public static final int FIELD_INITIAL_SIZE = 156;
  30         public static final int METHOD_INITIAL_SIZE = 236;
  31         public static final int INTERFACE_INITIAL_SIZE = 50;
  32         public static final int CLASS_INITIAL_SIZE = 86;
  33         public static final int NAMEANDTYPE_INITIAL_SIZE = 272;
  34         public static final int CONSTANTPOOL_INITIAL_SIZE = 2000;
  35         public static final int CONSTANTPOOL_GROW_SIZE = 6000;
  36         protected DoubleCache doubleCache;
  37         protected FloatCache floatCache;
  38         protected IntegerCache intCache;
  39         protected LongCache longCache;
  40         public CharArrayCache UTF8Cache;
  41         protected CharArrayCache stringCache;
  42         protected ObjectCache fieldCache;
  43         protected ObjectCache methodCache;
  44         protected ObjectCache interfaceMethodCache;
  45         protected ObjectCache classCache;
  46         protected FieldNameAndTypeCache nameAndTypeCacheForFields;
  47         protected MethodNameAndTypeCache nameAndTypeCacheForMethods;
  48         int[] wellKnownTypes = new int[21];
  49         int[] wellKnownMethods = new int[36];
  50         int[] wellKnownFields = new int[10];
  51         int[] wellKnownFieldNameAndTypes = new int[2];
  52         int[] wellKnownMethodNameAndTypes = new int[33];
  53         public byte[] poolContent;
  54         public int currentIndex = 1;
  55         public int currentOffset;
  56         // predefined constant index for well known types
  57         final static int JAVA_LANG_BOOLEAN_TYPE = 0;
  58         final static int JAVA_LANG_BYTE_TYPE = 1;
  59         final static int JAVA_LANG_CHARACTER_TYPE = 2;
  60         final static int JAVA_LANG_DOUBLE_TYPE = 3;
  61         final static int JAVA_LANG_FLOAT_TYPE = 4;
  62         final static int JAVA_LANG_INTEGER_TYPE = 5;
  63         final static int JAVA_LANG_LONG_TYPE = 6;
  64         final static int JAVA_LANG_SHORT_TYPE = 7;
  65         final static int JAVA_LANG_VOID_TYPE = 8;
  66         final static int JAVA_LANG_CLASS_TYPE = 9;
  67         final static int JAVA_LANG_CLASSNOTFOUNDEXCEPTION_TYPE = 10;
  68         final static int JAVA_LANG_NOCLASSDEFFOUNDERROR_TYPE = 11;
  69         final static int JAVA_LANG_OBJECT_TYPE = 12;
  70         final static int JAVA_LANG_STRING_TYPE = 13;
  71         final static int JAVA_LANG_STRINGBUFFER_TYPE = 14;
  72         final static int JAVA_LANG_SYSTEM_TYPE = 15;
  73         final static int JAVA_LANG_THROWABLE_TYPE = 16;
  74         final static int JAVA_LANG_ERROR_TYPE = 17;
  75         final static int JAVA_LANG_EXCEPTION_TYPE = 18;
  76         final static int JAVA_LANG_REFLECT_CONSTRUCTOR_TYPE = 19;
  77         final static int JAVA_LANG_ASSERTIONERROR_TYPE = 20;
  78
  79         // predefined constant index for well known fields
  80         final static int TYPE_BYTE_FIELD = 0;
  81         final static int TYPE_SHORT_FIELD = 1;
  82         final static int TYPE_CHARACTER_FIELD = 2;
  83         final static int TYPE_INTEGER_FIELD = 3;
  84         final static int TYPE_LONG_FIELD = 4;
  85         final static int TYPE_FLOAT_FIELD = 5;
  86         final static int TYPE_DOUBLE_FIELD = 6;
  87         final static int TYPE_BOOLEAN_FIELD = 7;
  88         final static int TYPE_VOID_FIELD = 8;
  89         final static int OUT_SYSTEM_FIELD = 9;
  90         // predefined constant index for well known methods
  91         final static int FORNAME_CLASS_METHOD = 0;
  92         final static int NOCLASSDEFFOUNDERROR_CONSTR_METHOD = 1;
  93         final static int APPEND_INT_METHOD = 2;
  94         final static int APPEND_FLOAT_METHOD = 3;
  95         final static int APPEND_LONG_METHOD = 4;
  96         final static int APPEND_OBJECT_METHOD = 5;
  97         final static int APPEND_CHAR_METHOD = 6;
  98         final static int APPEND_STRING_METHOD = 7;
  99         final static int APPEND_BOOLEAN_METHOD = 8;
 100         final static int APPEND_DOUBLE_METHOD = 9;
 101         final static int STRINGBUFFER_STRING_CONSTR_METHOD = 10;
 102         final static int STRINGBUFFER_DEFAULT_CONSTR_METHOD = 11;
 103         final static int STRINGBUFFER_TOSTRING_METHOD = 12;
 104         final static int SYSTEM_EXIT_METHOD = 13;
 105         final static int THROWABLE_GETMESSAGE_METHOD = 14;
 106         final static int JAVALANGERROR_CONSTR_METHOD = 15;
 107         final static int GETCONSTRUCTOR_CLASS_METHOD = 16;
 108         final static int NEWINSTANCE_CONSTRUCTOR_METHOD = 17;
 109         final static int STRING_INTERN_METHOD = 18;
 110         final static int VALUEOF_INT_METHOD = 19;
 111         final static int VALUEOF_FLOAT_METHOD = 20;
 112         final static int VALUEOF_LONG_METHOD = 21;
 113         final static int VALUEOF_OBJECT_METHOD = 22;
 114         final static int VALUEOF_CHAR_METHOD = 23;
 115         final static int VALUEOF_BOOLEAN_METHOD = 24;
 116         final static int VALUEOF_DOUBLE_METHOD = 25;
 117         final static int ASSERTIONERROR_CONSTR_OBJECT_METHOD = 26;
 118         final static int ASSERTIONERROR_CONSTR_INT_METHOD = 27;
 119         final static int ASSERTIONERROR_CONSTR_LONG_METHOD = 28;
 120         final static int ASSERTIONERROR_CONSTR_FLOAT_METHOD = 29;
 121         final static int ASSERTIONERROR_CONSTR_DOUBLE_METHOD = 30;
 122         final static int ASSERTIONERROR_CONSTR_BOOLEAN_METHOD = 31;
 123         final static int ASSERTIONERROR_CONSTR_CHAR_METHOD = 32;
 124         final static int ASSERTIONERROR_DEFAULT_CONSTR_METHOD = 33;
 125         final static int DESIREDASSERTIONSTATUS_CLASS_METHOD = 34;
 126         final static int GETCLASS_OBJECT_METHOD = 35;
 127         // predefined constant index for well known name and type for fields
 128         final static int TYPE_JAVALANGCLASS_NAME_AND_TYPE = 0;
 129         final static int OUT_SYSTEM_NAME_AND_TYPE = 1;
 130         // predefined constant index for well known name and type for methods
 131         final static int FORNAME_CLASS_METHOD_NAME_AND_TYPE = 0;
 132         final static int CONSTR_STRING_METHOD_NAME_AND_TYPE = 1;
 133         final static int DEFAULT_CONSTR_METHOD_NAME_AND_TYPE = 2;
 134         final static int APPEND_INT_METHOD_NAME_AND_TYPE = 3;
 135         final static int APPEND_FLOAT_METHOD_NAME_AND_TYPE = 4;
 136         final static int APPEND_LONG_METHOD_NAME_AND_TYPE = 5;
 137         final static int APPEND_OBJECT_METHOD_NAME_AND_TYPE = 6;
 138         final static int APPEND_CHAR_METHOD_NAME_AND_TYPE = 7;
 139         final static int APPEND_STRING_METHOD_NAME_AND_TYPE = 8;
 140         final static int APPEND_BOOLEAN_METHOD_NAME_AND_TYPE = 9;
 141         final static int APPEND_DOUBLE_METHOD_NAME_AND_TYPE = 10;
 142         final static int TOSTRING_METHOD_NAME_AND_TYPE = 11;
 143         final static int EXIT_METHOD_NAME_AND_TYPE = 12;
 144         final static int GETMESSAGE_METHOD_NAME_AND_TYPE = 13;
 145         final static int GETCONSTRUCTOR_METHOD_NAME_AND_TYPE = 14;
 146         final static int NEWINSTANCE_METHOD_NAME_AND_TYPE = 15;
 147         final static int INTERN_METHOD_NAME_AND_TYPE = 16;
 148         final static int VALUEOF_INT_METHOD_NAME_AND_TYPE = 17;
 149         final static int VALUEOF_FLOAT_METHOD_NAME_AND_TYPE = 18;
 150         final static int VALUEOF_LONG_METHOD_NAME_AND_TYPE = 19;
 151         final static int VALUEOF_OBJECT_METHOD_NAME_AND_TYPE = 20;
 152         final static int VALUEOF_CHAR_METHOD_NAME_AND_TYPE = 21;
 153         final static int VALUEOF_BOOLEAN_METHOD_NAME_AND_TYPE = 22;
 154         final static int VALUEOF_DOUBLE_METHOD_NAME_AND_TYPE = 23;
 155         final static int CONSTR_INT_METHOD_NAME_AND_TYPE = 24;
 156         final static int CONSTR_LONG_METHOD_NAME_AND_TYPE = 25;
 157         final static int CONSTR_FLOAT_METHOD_NAME_AND_TYPE = 26;
 158         final static int CONSTR_DOUBLE_METHOD_NAME_AND_TYPE = 27;
 159         final static int CONSTR_OBJECT_METHOD_NAME_AND_TYPE = 28;
 160         final static int CONSTR_CHAR_METHOD_NAME_AND_TYPE = 29;
 161         final static int CONSTR_BOOLEAN_METHOD_NAME_AND_TYPE = 30;
 162         final static int DESIREDASSERTIONSTATUS_METHOD_NAME_AND_TYPE = 31;
 163         final static int GETCLASS_OBJECT_METHOD_NAME_AND_TYPE = 32;
 164
 165
 166         public ClassFile classFile;
 167
 168 /**
 169  * ConstantPool constructor comment.
 170  */
 171 public ConstantPool(ClassFile classFile) {
 172         this.UTF8Cache = new CharArrayCache(UTF8_INITIAL_SIZE);
 173         this.stringCache = new CharArrayCache(STRING_INITIAL_SIZE);
 174         this.fieldCache = new ObjectCache(FIELD_INITIAL_SIZE);
 175         this.methodCache = new ObjectCache(METHOD_INITIAL_SIZE);
 176         this.interfaceMethodCache = new ObjectCache(INTERFACE_INITIAL_SIZE);
 177         this.classCache = new ObjectCache(CLASS_INITIAL_SIZE);
 178         this.nameAndTypeCacheForMethods = new MethodNameAndTypeCache(NAMEANDTYPE_INITIAL_SIZE);
 179         this.nameAndTypeCacheForFields = new FieldNameAndTypeCache(NAMEANDTYPE_INITIAL_SIZE);
 180         this.poolContent = classFile.header;
 181         this.currentOffset = classFile.headerOffset;
 182         // currentOffset is initialized to 0 by default
 183         this.currentIndex = 1;
 184         this.classFile = classFile;
 185 }
 186 /**
 187  * Return the content of the receiver
 188  */
 189 public byte[] dumpBytes() {
 190         System.arraycopy(poolContent, 0, (poolContent = new byte[currentOffset]), 0, currentOffset);
 191         return poolContent;
 192 }
 193 /**
 194  * Return the index of the @fieldBinding.
 195  *
 196  * Returns -1 if the @fieldBinding is not a predefined fieldBinding,
 197  * the right index otherwise.
 198  *
 199  * @param fieldBinding org.eclipse.jdt.internal.compiler.lookup.FieldBinding
 200  * @return <CODE>int</CODE>
 201  */
 202 public int indexOfWellKnownFieldNameAndType(FieldBinding fieldBinding) {
 203         if ((fieldBinding.type.id == T_JavaLangClass) && (CharOperation.equals(fieldBinding.name, QualifiedNamesConstants.TYPE)))
 204                 return TYPE_JAVALANGCLASS_NAME_AND_TYPE;
 205         if ((fieldBinding.type.id == T_JavaIoPrintStream) && (CharOperation.equals(fieldBinding.name, QualifiedNamesConstants.Out)))
 206                 return OUT_SYSTEM_NAME_AND_TYPE;
 207         return -1;
 208 }
 209 /**
 210  * Return the index of the @fieldBinding.
 211  *
 212  * Returns -1 if the @fieldBinding is not a predefined fieldBinding,
 213  * the right index otherwise.
 214  *
 215  * @param fieldBinding org.eclipse.jdt.internal.compiler.lookup.FieldBinding
 216  * @return <CODE>int</CODE>
 217  */
 218 public int indexOfWellKnownFields(FieldBinding fieldBinding) {
 219         switch (fieldBinding.declaringClass.id) {
 220                 case T_JavaLangByte :
 221                         if (CharOperation.equals(fieldBinding.name, QualifiedNamesConstants.TYPE))
 222                                 return TYPE_BYTE_FIELD;
 223                         break;
 224                 case T_JavaLangShort :
 225                         if (CharOperation.equals(fieldBinding.name, QualifiedNamesConstants.TYPE))
 226                                 return TYPE_SHORT_FIELD;
 227                         break;
 228                 case T_JavaLangCharacter :
 229                         if (CharOperation.equals(fieldBinding.name, QualifiedNamesConstants.TYPE))
 230                                 return TYPE_CHARACTER_FIELD;
 231                         break;
 232                 case T_JavaLangInteger :
 233                         if (CharOperation.equals(fieldBinding.name, QualifiedNamesConstants.TYPE))
 234                                 return TYPE_INTEGER_FIELD;
 235                         break;
 236                 case T_JavaLangLong :
 237                         if (CharOperation.equals(fieldBinding.name, QualifiedNamesConstants.TYPE))
 238                                 return TYPE_LONG_FIELD;
 239                         break;
 240                 case T_JavaLangFloat :
 241                         if (CharOperation.equals(fieldBinding.name, QualifiedNamesConstants.TYPE))
 242                                 return TYPE_FLOAT_FIELD;
 243                         break;
 244                 case T_JavaLangDouble :
 245                         if (CharOperation.equals(fieldBinding.name, QualifiedNamesConstants.TYPE))
 246                                 return TYPE_DOUBLE_FIELD;
 247                         break;
 248                 case T_JavaLangBoolean :
 249                         if (CharOperation.equals(fieldBinding.name, QualifiedNamesConstants.TYPE))
 250                                 return TYPE_BOOLEAN_FIELD;
 251                         break;
 252                 case T_JavaLangVoid :
 253                         if (CharOperation.equals(fieldBinding.name, QualifiedNamesConstants.TYPE))
 254                                 return TYPE_VOID_FIELD;
 255                         break;
 256                 case T_JavaLangSystem :
 257                         if (CharOperation.equals(fieldBinding.name, QualifiedNamesConstants.Out))
 258                                 return OUT_SYSTEM_FIELD;
 259         }
 260         return -1;
 261 }
 262 /**
 263  * Return the index of the @methodBinding.
 264  *
 265  * Returns -1 if the @methodBinding is not a predefined methodBinding,
 266  * the right index otherwise.
 267  *
 268  * @param methodBinding org.eclipse.jdt.internal.compiler.lookup.MethodBinding
 269  * @return <CODE>int</CODE>
 270  */
 271 public int indexOfWellKnownMethodNameAndType(MethodBinding methodBinding) {
 272         char firstChar = methodBinding.selector[0];
 273         switch (firstChar) {
 274                 case 'f' :
 275                         if ((methodBinding.parameters.length == 1) && (methodBinding.parameters[0].id == T_JavaLangString) && (methodBinding.returnType.id == T_JavaLangClass) && (CharOperation.equals(methodBinding.selector, QualifiedNamesConstants.ForName))) {
 276                                 // This method binding is forName(java.lang.String)
 277                                 return FORNAME_CLASS_METHOD_NAME_AND_TYPE;
 278                         }
 279                         break;
 280                 case '<' :
 281                         if (CharOperation.equals(methodBinding.selector, QualifiedNamesConstants.Init)) {
 282                                 switch(methodBinding.parameters.length) {
 283                                         case 1:
 284                                                 switch(methodBinding.parameters[0].id) {
 285                                                         case T_String :
 286                                                                 if (CharOperation.equals(methodBinding.signature(), QualifiedNamesConstants.StringConstructorSignature)) {
 287                                                                         return CONSTR_STRING_METHOD_NAME_AND_TYPE;
 288                                                                 } else {
 289                                                                         return -1;
 290                                                                 }
 291                                                         case T_Object :
 292                                                                 if (CharOperation.equals(methodBinding.signature(), QualifiedNamesConstants.AssertionErrorObjectConstrSignature)) {
 293                                                                         return CONSTR_OBJECT_METHOD_NAME_AND_TYPE;
 294                                                                 } else {
 295                                                                         return -1;
 296                                                                 }
 297                                                         case T_int :
 298                                                                 if (CharOperation.equals(methodBinding.signature(), QualifiedNamesConstants.AssertionErrorIntConstrSignature)) {
 299                                                                         return CONSTR_INT_METHOD_NAME_AND_TYPE;
 300                                                                 } else {
 301                                                                         return -1;
 302                                                                 }
 303                                                         case T_char :
 304                                                                 if (CharOperation.equals(methodBinding.signature(), QualifiedNamesConstants.AssertionErrorCharConstrSignature)) {
 305                                                                         return CONSTR_CHAR_METHOD_NAME_AND_TYPE;
 306                                                                 } else {
 307                                                                         return -1;
 308                                                                 }
 309                                                         case T_boolean :
 310                                                                 if (CharOperation.equals(methodBinding.signature(), QualifiedNamesConstants.AssertionErrorBooleanConstrSignature)) {
 311                                                                         return CONSTR_BOOLEAN_METHOD_NAME_AND_TYPE;
 312                                                                 } else {
 313                                                                         return -1;
 314                                                                 }
 315                                                         case T_float :
 316                                                                 if (CharOperation.equals(methodBinding.signature(), QualifiedNamesConstants.AssertionErrorFloatConstrSignature)) {
 317                                                                         return CONSTR_FLOAT_METHOD_NAME_AND_TYPE;
 318                                                                 } else {
 319                                                                         return -1;
 320                                                                 }
 321                                                         case T_double :
 322                                                                 if (CharOperation.equals(methodBinding.signature(), QualifiedNamesConstants.AssertionErrorDoubleConstrSignature)) {
 323                                                                         return CONSTR_DOUBLE_METHOD_NAME_AND_TYPE;
 324                                                                 } else {
 325                                                                         return -1;
 326                                                                 }
 327                                                         case T_long :
 328                                                                 if (CharOperation.equals(methodBinding.signature(), QualifiedNamesConstants.AssertionErrorLongConstrSignature)) {
 329                                                                         return CONSTR_LONG_METHOD_NAME_AND_TYPE;
 330                                                                 } else {
 331                                                                         return -1;
 332                                                                 }
 333                                                 }
 334                                         case 0:
 335                                                 if (methodBinding.signature().length == 3) {
 336                                                         return DEFAULT_CONSTR_METHOD_NAME_AND_TYPE;
 337                                                 }
 338                                 }
 339                         }
 340                         break;
 341                 case 'a' :
 342                         if ((methodBinding.parameters.length == 1) && (methodBinding.returnType.id == T_JavaLangStringBuffer) && (CharOperation.equals(methodBinding.selector, QualifiedNamesConstants.Append))) {
 343                                 switch (methodBinding.parameters[0].id) {
 344                                         case T_int :
 345                                         case T_byte :
 346                                         case T_short :
 347                                                 // This method binding is append(int)
 348                                                 return APPEND_INT_METHOD_NAME_AND_TYPE;
 349                                         case T_float :
 350                                                 // This method binding is append(float)
 351                                                 return APPEND_FLOAT_METHOD_NAME_AND_TYPE;
 352                                         case T_long :
 353                                                 // This method binding is append(long)
 354                                                 return APPEND_LONG_METHOD_NAME_AND_TYPE;
 355                                         case T_JavaLangObject :
 356                                                 // This method binding is append(java.lang.Object)
 357                                                 return APPEND_OBJECT_METHOD_NAME_AND_TYPE;
 358                                         case T_char :
 359                                                 // This method binding is append(char)
 360                                                 return APPEND_CHAR_METHOD_NAME_AND_TYPE;
 361                                         case T_JavaLangString :
 362                                                 // This method binding is append(java.lang.String)
 363                                                 return APPEND_STRING_METHOD_NAME_AND_TYPE;
 364                                         case T_boolean :
 365                                                 // This method binding is append(boolean)
 366                                                 return APPEND_BOOLEAN_METHOD_NAME_AND_TYPE;
 367                                         case T_double :
 368                                                 // This method binding is append(double)
 369                                                 return APPEND_DOUBLE_METHOD_NAME_AND_TYPE;
 370                                 }
 371                         }
 372                         break;
 373                 case 't' :
 374                         if ((methodBinding.parameters.length == 0) && (methodBinding.returnType.id == T_JavaLangString) && (CharOperation.equals(methodBinding.selector, QualifiedNamesConstants.ToString))) {
 375                                 // This method binding is toString()
 376                                 return TOSTRING_METHOD_NAME_AND_TYPE;
 377                         }
 378                         break;
 379                 case 'v' :
 380                         if ((methodBinding.parameters.length == 1) && (methodBinding.returnType.id == T_JavaLangString) && (CharOperation.equals(methodBinding.selector, QualifiedNamesConstants.ValueOf))) {
 381                                 switch(methodBinding.parameters[0].id) {
 382                                         case T_Object:
 383                                                 return VALUEOF_OBJECT_METHOD_NAME_AND_TYPE;
 384                                         case T_int:
 385                                         case T_short:
 386                                         case T_byte:
 387                                                 return VALUEOF_INT_METHOD_NAME_AND_TYPE;
 388                                         case T_long:
 389                                                 return VALUEOF_LONG_METHOD_NAME_AND_TYPE;
 390                                         case T_float:
 391                                                 return VALUEOF_FLOAT_METHOD_NAME_AND_TYPE;
 392                                         case T_double:
 393                                                 return VALUEOF_DOUBLE_METHOD_NAME_AND_TYPE;
 394                                         case T_boolean:
 395                                                 return VALUEOF_BOOLEAN_METHOD_NAME_AND_TYPE;
 396                                         case T_char:
 397                                                 return VALUEOF_CHAR_METHOD_NAME_AND_TYPE;
 398                                 }
 399                         }
 400                         break;
 401                 case 'e' :
 402                         if ((methodBinding.parameters.length == 1) && (methodBinding.parameters[0].id == T_int) && (methodBinding.returnType.id == T_void) && (CharOperation.equals(methodBinding.selector, QualifiedNamesConstants.Exit))) {
 403                                 // This method binding is exit(int)
 404                                 return EXIT_METHOD_NAME_AND_TYPE;
 405                         }
 406                         break;
 407                 case 'g' :
 408                         if ((methodBinding.selector.length == 10)
 409                             && (methodBinding.parameters.length == 0)
 410                             && (methodBinding.returnType.id == T_JavaLangString)
 411                             && (CharOperation.equals(methodBinding.selector, QualifiedNamesConstants.GetMessage))) {
 412                                 // This method binding is getMessage()
 413                                 return GETMESSAGE_METHOD_NAME_AND_TYPE;
 414                         }
 415                         if (methodBinding.parameters.length == 0
 416                                 && methodBinding.returnType.id == T_JavaLangClass
 417                                 && CharOperation.equals(methodBinding.selector, QualifiedNamesConstants.GetClass)) {
 418                                         return GETCLASS_OBJECT_METHOD_NAME_AND_TYPE;
 419                         }
 420                         break;
 421                 case 'i' :
 422                         if ((methodBinding.parameters.length == 0) && (methodBinding.returnType.id == T_JavaLangString) && (CharOperation.equals(methodBinding.selector, QualifiedNamesConstants.Intern))) {
 423                                 // This method binding is toString()
 424                                 return INTERN_METHOD_NAME_AND_TYPE;
 425                         }
 426         }
 427         return -1;
 428 }
 429 /**
 430  * Return the index of the @methodBinding.
 431  *
 432  * Returns -1 if the @methodBinding is not a predefined methodBinding,
 433  * the right index otherwise.
 434  *
 435  * @param methodBinding org.eclipse.jdt.internal.compiler.lookup.MethodBinding
 436  * @return <CODE>int</CODE>
 437  */
 438 public int indexOfWellKnownMethods(MethodBinding methodBinding) {
 439         char firstChar = methodBinding.selector[0];
 440         switch (methodBinding.declaringClass.id) {
 441                 case T_JavaLangClass :
 442                         if ((firstChar == 'f') && (methodBinding.isStatic()) && (methodBinding.parameters.length == 1) && (methodBinding.parameters[0].id == T_JavaLangString) && (methodBinding.returnType.id == T_JavaLangClass) && (CharOperation.equals(methodBinding.selector, QualifiedNamesConstants.ForName))) {
 443                                 // This method binding is forName(java.lang.String)
 444                                 return FORNAME_CLASS_METHOD;
 445                         } else if ((firstChar == 'g') && (methodBinding.parameters.length == 1) && (methodBinding.returnType.id == T_JavaLangReflectConstructor) && CharOperation.equals(methodBinding.selector, QualifiedNamesConstants.GetConstructor) && CharOperation.equals(methodBinding.parameters[0].constantPoolName(), QualifiedNamesConstants.ArrayJavaLangClassConstantPoolName)) {
 446                                         return GETCONSTRUCTOR_CLASS_METHOD;
 447                         } else if ((firstChar == 'd') && (methodBinding.parameters.length == 0) && (methodBinding.returnType.id == T_boolean) && CharOperation.equals(methodBinding.selector, QualifiedNamesConstants.DesiredAssertionStatus)) {
 448                                         return DESIREDASSERTIONSTATUS_CLASS_METHOD;
 449                         }
 450                         break;
 451                 case T_JavaLangNoClassDefError :
 452                         if ((firstChar == '<') && (methodBinding.parameters.length == 1) && (methodBinding.parameters[0].id == T_JavaLangString) && (CharOperation.equals(methodBinding.selector, QualifiedNamesConstants.Init))) {
 453                                 // This method binding is NoClassDefFoundError(java.lang.String)
 454                                 return NOCLASSDEFFOUNDERROR_CONSTR_METHOD;
 455                         }
 456                         break;
 457                 case T_JavaLangReflectConstructor :
 458                         if ((firstChar == 'n') && (methodBinding.parameters.length == 1) && (methodBinding.returnType.id == T_JavaLangObject) && CharOperation.equals(methodBinding.selector, QualifiedNamesConstants.NewInstance) && CharOperation.equals(methodBinding.parameters[0].constantPoolName(), QualifiedNamesConstants.ArrayJavaLangObjectConstantPoolName)) {
 459                                 return NEWINSTANCE_CONSTRUCTOR_METHOD;
 460                         }
 461                         break;
 462                 case T_JavaLangStringBuffer :
 463                         if ((firstChar == 'a') && (methodBinding.parameters.length == 1) && (methodBinding.returnType.id == T_JavaLangStringBuffer) && (CharOperation.equals(methodBinding.selector, QualifiedNamesConstants.Append))) {
 464                                 switch (methodBinding.parameters[0].id) {
 465                                         case T_int :
 466                                         case T_byte :
 467                                         case T_short :
 468                                                 // This method binding is append(int)
 469                                                 return APPEND_INT_METHOD;
 470                                         case T_float :
 471                                                 // This method binding is append(float)
 472                                                 return APPEND_FLOAT_METHOD;
 473                                         case T_long :
 474                                                 // This method binding is append(long)
 475                                                 return APPEND_LONG_METHOD;
 476                                         case T_JavaLangObject :
 477                                                 // This method binding is append(java.lang.Object)
 478                                                 return APPEND_OBJECT_METHOD;
 479                                         case T_char :
 480                                                 // This method binding is append(char)
 481                                                 return APPEND_CHAR_METHOD;
 482                                         case T_JavaLangString :
 483                                                 // This method binding is append(java.lang.String)
 484                                                 return APPEND_STRING_METHOD;
 485                                         case T_boolean :
 486                                                 // This method binding is append(boolean)
 487                                                 return APPEND_BOOLEAN_METHOD;
 488                                         case T_double :
 489                                                 // This method binding is append(double)
 490                                                 return APPEND_DOUBLE_METHOD;
 491                                 }
 492                         } else
 493                                 if ((firstChar == 't') && (methodBinding.parameters.length == 0) && (methodBinding.returnType.id == T_JavaLangString) && (CharOperation.equals(methodBinding.selector, QualifiedNamesConstants.ToString))) {
 494                                         // This method binding is toString()
 495                                         return STRINGBUFFER_TOSTRING_METHOD;
 496                                 } else
 497                                         if ((firstChar == '<') && (CharOperation.equals(methodBinding.selector, QualifiedNamesConstants.Init))) {
 498                                                 if ((methodBinding.parameters.length == 1) && (methodBinding.parameters[0].id == T_JavaLangString)) {
 499                                                         // This method binding is <init>(String)
 500                                                         return STRINGBUFFER_STRING_CONSTR_METHOD;
 501                                                 } else {
 502                                                         if (methodBinding.parameters.length == 0) {
 503                                                                 // This method binding is <init>()
 504                                                                 return STRINGBUFFER_DEFAULT_CONSTR_METHOD;
 505                                                         }
 506                                                 }
 507                                         }
 508                         break;
 509                 case T_JavaLangString :
 510                         if ((firstChar == 'v') && (methodBinding.parameters.length == 1) && (methodBinding.returnType.id == T_JavaLangString) && (CharOperation.equals(methodBinding.selector, QualifiedNamesConstants.ValueOf))) {
 511                                 // This method binding is valueOf(java.lang.Object)
 512                                 switch (methodBinding.parameters[0].id) {
 513                                         case T_Object :
 514                                                 return VALUEOF_OBJECT_METHOD;
 515                                         case T_int :
 516                                         case T_short :
 517                                         case T_byte :
 518                                                 return VALUEOF_INT_METHOD;
 519                                         case T_long :
 520                                                 return VALUEOF_LONG_METHOD;
 521                                         case T_float :
 522                                                 return VALUEOF_FLOAT_METHOD;
 523                                         case T_double :
 524                                                 return VALUEOF_DOUBLE_METHOD;
 525                                         case T_boolean :
 526                                                 return VALUEOF_BOOLEAN_METHOD;
 527                                         case T_char :
 528                                                 return VALUEOF_CHAR_METHOD;
 529                                 }
 530                         } else
 531                                 if ((firstChar == 'i') && (methodBinding.parameters.length == 0) && (methodBinding.returnType.id == T_JavaLangString) && (CharOperation.equals(methodBinding.selector, QualifiedNamesConstants.Intern))) {
 532                                         // This method binding is valueOf(java.lang.Object)
 533                                         return STRING_INTERN_METHOD;
 534                                 }
 535                         break;
 536                 case T_JavaLangSystem :
 537                         if ((firstChar == 'e') && (methodBinding.parameters.length == 1) && (methodBinding.parameters[0].id == T_int) && (methodBinding.returnType.id == T_void) && (CharOperation.equals(methodBinding.selector, QualifiedNamesConstants.Exit))) {
 538                                 // This method binding is exit(int)
 539                                 return SYSTEM_EXIT_METHOD;
 540                         }
 541                         break;
 542                 case T_JavaLangThrowable :
 543                         if ((firstChar == 'g') && (methodBinding.selector.length == 10) && (methodBinding.parameters.length == 0) && (methodBinding.returnType.id == T_JavaLangString) && (CharOperation.equals(methodBinding.selector, QualifiedNamesConstants.GetMessage))) {
 544                                 // This method binding is getMessage()
 545                                 return THROWABLE_GETMESSAGE_METHOD;
 546                         }
 547                         break;
 548                 case T_JavaLangError :
 549                         if ((firstChar == '<') && (methodBinding.parameters.length == 1) && (CharOperation.equals(methodBinding.selector, QualifiedNamesConstants.Init)) && (methodBinding.parameters[0].id == T_String)) {
 550                                 return JAVALANGERROR_CONSTR_METHOD;
 551                         }
 552                         break;
 553                 case T_JavaLangAssertionError :
 554                         if ((firstChar == '<') && CharOperation.equals(methodBinding.selector, QualifiedNamesConstants.Init)) {
 555                                 switch (methodBinding.parameters.length) {
 556                                         case 0:
 557                                                 return ASSERTIONERROR_DEFAULT_CONSTR_METHOD;
 558                                         case 1:
 559                                                 switch(methodBinding.parameters[0].id) {
 560                                                         case T_boolean :
 561                                                                 return ASSERTIONERROR_CONSTR_BOOLEAN_METHOD;
 562                                                         case T_char :
 563                                                                 return ASSERTIONERROR_CONSTR_CHAR_METHOD;
 564                                                         case T_double :
 565                                                                 return ASSERTIONERROR_CONSTR_DOUBLE_METHOD;
 566                                                         case T_int :
 567                                                         case T_byte :
 568                                                         case T_short :
 569                                                                 return ASSERTIONERROR_CONSTR_INT_METHOD;
 570                                                         case T_float :
 571                                                                 return ASSERTIONERROR_CONSTR_FLOAT_METHOD;
 572                                                         case T_long :
 573                                                                 return ASSERTIONERROR_CONSTR_LONG_METHOD;
 574                                                         default:
 575                                                                 return ASSERTIONERROR_CONSTR_OBJECT_METHOD;
 576                                                 }
 577                                 }
 578                         }
 579                         break;
 580                 case T_JavaLangObject :
 581                         if (methodBinding.parameters.length == 0
 582                                 && CharOperation.equals(methodBinding.selector, QualifiedNamesConstants.GetClass)) {
 583                                         return GETCLASS_OBJECT_METHOD;
 584                         }
 585         }
 586         return -1;
 587 }
 588 /**
 589  * Return the index of the @typeBinding
 590  *
 591  * Returns -1 if the @typeBinding is not a predefined binding, the right index
 592  * otherwise.
 593  *
 594  * @param typeBinding org.eclipse.jdt.internal.compiler.lookup.TypeBinding
 595  * @return <CODE>int</CODE>
 596  */
 597 public int indexOfWellKnownTypes(TypeBinding typeBinding) {
 598         switch(typeBinding.id) {
 599                 case T_JavaLangBoolean : return JAVA_LANG_BOOLEAN_TYPE;
 600                 case T_JavaLangByte : return JAVA_LANG_BYTE_TYPE;
 601                 case T_JavaLangCharacter : return JAVA_LANG_CHARACTER_TYPE;
 602                 case T_JavaLangDouble : return JAVA_LANG_DOUBLE_TYPE;
 603                 case T_JavaLangFloat : return JAVA_LANG_FLOAT_TYPE;
 604                 case T_JavaLangInteger : return JAVA_LANG_INTEGER_TYPE;
 605                 case T_JavaLangLong : return JAVA_LANG_LONG_TYPE;
 606                 case T_JavaLangShort : return JAVA_LANG_SHORT_TYPE;
 607                 case T_JavaLangVoid : return JAVA_LANG_VOID_TYPE;
 608                 case T_JavaLangClass : return JAVA_LANG_CLASS_TYPE;
 609                 case T_JavaLangClassNotFoundException : return JAVA_LANG_CLASSNOTFOUNDEXCEPTION_TYPE;
 610                 case T_JavaLangNoClassDefError : return JAVA_LANG_NOCLASSDEFFOUNDERROR_TYPE;
 611                 case T_JavaLangObject : return JAVA_LANG_OBJECT_TYPE;
 612                 case T_JavaLangString : return JAVA_LANG_STRING_TYPE;
 613                 case T_JavaLangStringBuffer : return JAVA_LANG_STRINGBUFFER_TYPE;
 614                 case T_JavaLangSystem : return JAVA_LANG_SYSTEM_TYPE;
 615                 case T_JavaLangThrowable : return JAVA_LANG_THROWABLE_TYPE;
 616                 case T_JavaLangError : return JAVA_LANG_ERROR_TYPE;
 617                 case T_JavaLangException : return JAVA_LANG_EXCEPTION_TYPE;
 618                 case T_JavaLangReflectConstructor : return JAVA_LANG_REFLECT_CONSTRUCTOR_TYPE;
 619                 case T_JavaLangAssertionError : return JAVA_LANG_ASSERTIONERROR_TYPE;
 620         }
 621         return -1;
 622 }
 623 public int literalIndex(byte[] utf8encoding, char[] stringCharArray) {
 624         int index;
 625         if ((index = UTF8Cache.get(stringCharArray)) < 0) {
 626                 // The entry doesn't exit yet
 627                 index = UTF8Cache.put(stringCharArray, currentIndex);
 628                 if (index > 0xFFFF){
 629                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
 630                 }
 631                 currentIndex++;
 632                 // Write the tag first
 633                 writeU1(Utf8Tag);
 634                 // Then the size of the stringName array
 635                 //writeU2(utf8Constant.length);
 636                 int savedCurrentOffset = currentOffset;
 637                 if (currentOffset + 2 >= poolContent.length) {
 638                         // we need to resize the poolContent array because we won't have
 639                         // enough space to write the length
 640                         int length = poolContent.length;
 641                         System.arraycopy(poolContent, 0, (poolContent = new byte[length + CONSTANTPOOL_GROW_SIZE]), 0, length);
 642                 }
 643                 currentOffset += 2;
 644                 // add in once the whole byte array
 645                 int length = poolContent.length;
 646                 int utf8encodingLength = utf8encoding.length;
 647                 if (currentOffset + utf8encodingLength >= length) {
 648                         System.arraycopy(poolContent, 0, (poolContent = new byte[length + utf8encodingLength + CONSTANTPOOL_GROW_SIZE]), 0, length);
 649                 }
 650                 System.arraycopy(utf8encoding, 0, poolContent, currentOffset, utf8encodingLength);
 651                 currentOffset += utf8encodingLength;
 652                 // Now we know the length that we have to write in the constant pool
 653                 // we use savedCurrentOffset to do that
 654                 poolContent[savedCurrentOffset] = (byte) (utf8encodingLength >> 8);
 655                 poolContent[savedCurrentOffset + 1] = (byte) utf8encodingLength;
 656         }
 657         return index;
 658 }
 659 /**
 660  * This method returns the index into the constantPool corresponding to the type descriptor.
 661  *
 662  * @param char[] stringName
 663  * @return <CODE>int</CODE>
 664  */
 665 public int literalIndex(char[] utf8Constant) {
 666         int index;
 667         if ((index = UTF8Cache.get(utf8Constant)) < 0) {
 668                 // The entry doesn't exit yet
 669                 // Write the tag first
 670                 writeU1(Utf8Tag);
 671                 // Then the size of the stringName array
 672                 int savedCurrentOffset = currentOffset;
 673                 if (currentOffset + 2 >= poolContent.length) {
 674                         // we need to resize the poolContent array because we won't have
 675                         // enough space to write the length
 676                         int length = poolContent.length;
 677                         System.arraycopy(poolContent, 0, (poolContent = new byte[length + CONSTANTPOOL_GROW_SIZE]), 0, length);
 678                 }
 679                 currentOffset += 2;
 680                 int length = 0;
 681                 for (int i = 0; i < utf8Constant.length; i++) {
 682                         char current = utf8Constant[i];
 683                         if ((current >= 0x0001) && (current <= 0x007F)) {
 684                                 // we only need one byte: ASCII table
 685                                 writeU1(current);
 686                                 length++;
 687                         } else
 688                                 if (current > 0x07FF) {
 689                                         // we need 3 bytes
 690                                         length += 3;
 691                                         writeU1(0xE0 | ((current >> 12) & 0x0F)); // 0xE0 = 1110 0000
 692                                         writeU1(0x80 | ((current >> 6) & 0x3F)); // 0x80 = 1000 0000
 693                                         writeU1(0x80 | (current & 0x3F)); // 0x80 = 1000 0000
 694                                 } else {
 695                                         // we can be 0 or between 0x0080 and 0x07FF
 696                                         // In that case we only need 2 bytes
 697                                         length += 2;
 698                                         writeU1(0xC0 | ((current >> 6) & 0x1F)); // 0xC0 = 1100 0000
 699                                         writeU1(0x80 | (current & 0x3F)); // 0x80 = 1000 0000
 700                                 }
 701                 }
 702                 if (length >= 65535) {
 703                         currentOffset = savedCurrentOffset - 1;
 704                         return -1;
 705                 }
 706                 index = UTF8Cache.put(utf8Constant, currentIndex);
 707                 if (index > 0xFFFF){
 708                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
 709                 }
 710                 currentIndex++;
 711                 // Now we know the length that we have to write in the constant pool
 712                 // we use savedCurrentOffset to do that
 713                 poolContent[savedCurrentOffset] = (byte) (length >> 8);
 714                 poolContent[savedCurrentOffset + 1] = (byte) length;
 715         }
 716         return index;
 717 }
 718 public int literalIndex(char[] stringCharArray, byte[] utf8encoding) {
 719         int index;
 720         int stringIndex;
 721         if ((index = stringCache.get(stringCharArray)) < 0) {
 722                 // The entry doesn't exit yet
 723                 stringIndex = literalIndex(utf8encoding, stringCharArray);
 724                 index = stringCache.put(stringCharArray, currentIndex++);
 725                 if (index > 0xFFFF){
 726                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
 727                 }
 728                 // Write the tag first
 729                 writeU1(StringTag);
 730                 // Then the string index
 731                 writeU2(stringIndex);
 732         }
 733         return index;
 734 }
 735 /**
 736  * This method returns the index into the constantPool corresponding to the double
 737  * value. If the double is not already present into the pool, it is added. The
 738  * double cache is updated and it returns the right index.
 739  *
 740  * @param <CODE>double</CODE> key
 741  * @return <CODE>int</CODE>
 742  */
 743 public int literalIndex(double key) {
 744         //Retrieve the index from the cache
 745         // The double constant takes two indexes into the constant pool, but we only store
 746         // the first index into the long table
 747         int index;
 748         // lazy initialization for base type caches
 749         // If it is null, initialize it, otherwise use it
 750         if (doubleCache == null) {
 751                         doubleCache = new DoubleCache(DOUBLE_INITIAL_SIZE);
 752         }
 753         if ((index = doubleCache.get(key)) < 0) {
 754                 index = doubleCache.put(key, currentIndex++);
 755                 if (index > 0xFFFF){
 756                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
 757                 }
 758                 currentIndex++; // a double needs an extra place into the constant pool
 759                 // Write the double into the constant pool
 760                 // First add the tag
 761                 writeU1(DoubleTag);
 762                 // Then add the 8 bytes representing the double
 763                 long temp = java.lang.Double.doubleToLongBits(key);
 764                 for (int i = 0; i < 8; i++) {
 765                         try {
 766                                 poolContent[currentOffset++] = (byte) (temp >>> (56 - (i << 3)));
 767                         } catch (IndexOutOfBoundsException e) { //currentOffset has been ++ already (see the -1)
 768                                 int length = poolContent.length;
 769                                 System.arraycopy(poolContent, 0, (poolContent = new byte[(length << 1) + CONSTANTPOOL_INITIAL_SIZE]), 0, length);
 770                                 poolContent[currentOffset - 1] = (byte) (temp >>> (56 - (i << 3)));
 771                         }
 772                 }
 773         };
 774         return index;
 775 }
 776 /**
 777  * This method returns the index into the constantPool corresponding to the float
 778  * value. If the float is not already present into the pool, it is added. The
 779  * int cache is updated and it returns the right index.
 780  *
 781  * @param <CODE>float</CODE> key
 782  * @return <CODE>int</CODE>
 783  */
 784 public int literalIndex(float key) {
 785         //Retrieve the index from the cache
 786         int index;
 787         // lazy initialization for base type caches
 788         // If it is null, initialize it, otherwise use it
 789         if (floatCache == null) {
 790                 floatCache = new FloatCache(FLOAT_INITIAL_SIZE);
 791         }
 792         if ((index = floatCache.get(key)) < 0) {
 793                 index = floatCache.put(key, currentIndex++);
 794                 if (index > 0xFFFF){
 795                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
 796                 }
 797                 // Write the float constant entry into the constant pool
 798                 // First add the tag
 799                 writeU1(FloatTag);
 800                 // Then add the 4 bytes representing the float
 801                 int temp = java.lang.Float.floatToIntBits(key);
 802                 for (int i = 0; i < 4; i++) {
 803                         try {
 804                                 poolContent[currentOffset++] = (byte) (temp >>> (24 - i * 8));
 805                         } catch (IndexOutOfBoundsException e) { //currentOffset has been ++ already (see the -1)
 806                                 int length = poolContent.length;
 807                                 System.arraycopy(poolContent, 0, (poolContent = new byte[length * 2 + CONSTANTPOOL_INITIAL_SIZE]), 0, length);
 808                                 poolContent[currentOffset - 1] = (byte) (temp >>> (24 - i * 8));
 809                         }
 810                 }
 811         };
 812         return index;
 813 }
 814 /**
 815  * This method returns the index into the constantPool corresponding to the int
 816  * value. If the int is not already present into the pool, it is added. The
 817  * int cache is updated and it returns the right index.
 818  *
 819  * @param <CODE>int</CODE> key
 820  * @return <CODE>int</CODE>
 821  */
 822 public int literalIndex(int key) {
 823         //Retrieve the index from the cache
 824         int index;
 825         // lazy initialization for base type caches
 826         // If it is null, initialize it, otherwise use it
 827         if (intCache == null) {
 828                 intCache = new IntegerCache(INT_INITIAL_SIZE);
 829         }
 830         if ((index = intCache.get(key)) < 0) {
 831                 index = intCache.put(key, currentIndex++);
 832                 if (index > 0xFFFF){
 833                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
 834                 }
 835                 // Write the integer constant entry into the constant pool
 836                 // First add the tag
 837                 writeU1(IntegerTag);
 838                 // Then add the 4 bytes representing the int
 839                 for (int i = 0; i < 4; i++) {
 840                         try {
 841                                 poolContent[currentOffset++] = (byte) (key >>> (24 - i * 8));
 842                         } catch (IndexOutOfBoundsException e) { //currentOffset has been ++ already (see the -1)
 843                                 int length = poolContent.length;
 844                                 System.arraycopy(poolContent, 0, (poolContent = new byte[length * 2 + CONSTANTPOOL_INITIAL_SIZE]), 0, length);
 845                                 poolContent[currentOffset - 1] = (byte) (key >>> (24 - i * 8));
 846                         }
 847                 }
 848         };
 849         return index;
 850 }
 851 /**
 852  * This method returns the index into the constantPool corresponding to the long
 853  * value. If the long is not already present into the pool, it is added. The
 854  * long cache is updated and it returns the right index.
 855  *
 856  * @param <CODE>long</CODE> key
 857  * @return <CODE>int</CODE>
 858  */
 859 public int literalIndex(long key) {
 860         // Retrieve the index from the cache
 861         // The long constant takes two indexes into the constant pool, but we only store
 862         // the first index into the long table
 863         int index;
 864         // lazy initialization for base type caches
 865         // If it is null, initialize it, otherwise use it
 866         if (longCache == null) {
 867                 longCache = new LongCache(LONG_INITIAL_SIZE);
 868         }
 869         if ((index = longCache.get(key)) < 0) {
 870                 index = longCache.put(key, currentIndex++);
 871                 if (index > 0xFFFF){
 872                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
 873                 }
 874                 currentIndex++; // long value need an extra place into thwe constant pool
 875                 // Write the long into the constant pool
 876                 // First add the tag
 877                 writeU1(LongTag);
 878                 // Then add the 8 bytes representing the long
 879                 for (int i = 0; i < 8; i++) {
 880                         try {
 881                                 poolContent[currentOffset++] = (byte) (key >>> (56 - (i << 3)));
 882                         } catch (IndexOutOfBoundsException e) { //currentOffset has been ++ already (see the -1)
 883                                 int length = poolContent.length;
 884                                 System.arraycopy(poolContent, 0, (poolContent = new byte[(length << 1) + CONSTANTPOOL_INITIAL_SIZE]), 0, length);
 885                                 poolContent[currentOffset - 1] = (byte) (key >>> (56 - (i << 3)));
 886                         }
 887                 }
 888         }
 889         return index;
 890 }
 891 /**
 892  * This method returns the index into the constantPool corresponding to the type descriptor.
 893  *
 894  * @param stringConstant java.lang.String
 895  * @return <CODE>int</CODE>
 896  */
 897 public int literalIndex(String stringConstant) {
 898         int index;
 899         char[] stringCharArray = stringConstant.toCharArray();
 900         if ((index = stringCache.get(stringCharArray)) < 0) {
 901                 // The entry doesn't exit yet
 902                 int stringIndex = literalIndex(stringCharArray);
 903                 index = stringCache.put(stringCharArray, currentIndex++);
 904                 if (index > 0xFFFF){
 905                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
 906                 }
 907                 // Write the tag first
 908                 writeU1(StringTag);
 909                 // Then the string index
 910                 writeU2(stringIndex);
 911         }
 912         return index;
 913 }
 914 /**
 915  * This method returns the index into the constantPool
 916  * corresponding to the field binding aFieldBinding.
 917  *
 918  * @param FieldBinding aFieldBinding
 919  * @return <CODE>int</CODE>
 920  */
 921 public int literalIndex(FieldBinding aFieldBinding) {
 922         int index;
 923         int nameAndTypeIndex;
 924         int classIndex;
 925         int indexWellKnownField;
 926         if ((indexWellKnownField = indexOfWellKnownFields(aFieldBinding)) == -1) {
 927                 if ((index = fieldCache.get(aFieldBinding)) < 0) {
 928                         // The entry doesn't exit yet
 929                         classIndex = literalIndex(aFieldBinding.declaringClass);
 930                         nameAndTypeIndex = literalIndexForFields(literalIndex(aFieldBinding.name), literalIndex(aFieldBinding.type.signature()), aFieldBinding);
 931                         index = fieldCache.put(aFieldBinding, currentIndex++);
 932                         if (index > 0xFFFF){
 933                                 this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
 934                         }
 935                         writeU1(FieldRefTag);
 936                         writeU2(classIndex);
 937                         writeU2(nameAndTypeIndex);
 938                 }
 939         } else {
 940                 if ((index = wellKnownFields[indexWellKnownField]) == 0) {
 941                         // that field need to be inserted
 942                         classIndex = literalIndex(aFieldBinding.declaringClass);
 943                         nameAndTypeIndex = literalIndexForFields(literalIndex(aFieldBinding.name), literalIndex(aFieldBinding.type.signature()), aFieldBinding);
 944                         index = wellKnownFields[indexWellKnownField] = currentIndex++;
 945                         if (index > 0xFFFF){
 946                                 this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
 947                         }
 948                         writeU1(FieldRefTag);
 949                         writeU2(classIndex);
 950                         writeU2(nameAndTypeIndex);
 951                 }
 952         }
 953         return index;
 954 }
 955 /**
 956  * This method returns the index into the constantPool corresponding to the
 957  * method descriptor. It can be either an interface method reference constant
 958  * or a method reference constant.
 959  *
 960  * @param MethodBinding aMethodBinding
 961  * @return <CODE>int</CODE>
 962  */
 963 public int literalIndex(MethodBinding aMethodBinding) {
 964         int index;
 965         int nameAndTypeIndex;
 966         int classIndex;
 967         int indexWellKnownMethod;
 968         if ((indexWellKnownMethod = indexOfWellKnownMethods(aMethodBinding)) == -1) {
 969                 if (aMethodBinding.declaringClass.isInterface()) {
 970                         // Lookinf into the interface method ref table
 971                         if ((index = interfaceMethodCache.get(aMethodBinding)) < 0) {
 972                                 classIndex = literalIndex(aMethodBinding.declaringClass);
 973                                 nameAndTypeIndex = literalIndexForMethods(literalIndex(aMethodBinding.constantPoolName()), literalIndex(aMethodBinding.signature()), aMethodBinding);
 974                                 index = interfaceMethodCache.put(aMethodBinding, currentIndex++);
 975                                 if (index > 0xFFFF){
 976                                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
 977                                 }
 978                                 // Write the interface method ref constant into the constant pool
 979                                 // First add the tag
 980                                 writeU1(InterfaceMethodRefTag);
 981                                 // Then write the class index
 982                                 writeU2(classIndex);
 983                                 // The write the nameAndType index
 984                                 writeU2(nameAndTypeIndex);
 985                         }
 986                 } else {
 987                         // Lookinf into the method ref table
 988                         if ((index = methodCache.get(aMethodBinding)) < 0) {
 989                                 classIndex = literalIndex(aMethodBinding.declaringClass);
 990                                 nameAndTypeIndex = literalIndexForMethods(literalIndex(aMethodBinding.constantPoolName()), literalIndex(aMethodBinding.signature()), aMethodBinding);
 991                                 index = methodCache.put(aMethodBinding, currentIndex++);
 992                                 if (index > 0xFFFF){
 993                                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
 994                                 }
 995                                 // Write the method ref constant into the constant pool
 996                                 // First add the tag
 997                                 writeU1(MethodRefTag);
 998                                 // Then write the class index
 999                                 writeU2(classIndex);
1000                                 // The write the nameAndType index
1001                                 writeU2(nameAndTypeIndex);
1002                         }
1003                 }
1004         } else {
1005                 // This is a well known method
1006                 if ((index = wellKnownMethods[indexWellKnownMethod]) == 0) {
1007                         // this methods was not inserted yet
1008                         if (aMethodBinding.declaringClass.isInterface()) {
1009                                 // Lookinf into the interface method ref table
1010                                 classIndex = literalIndex(aMethodBinding.declaringClass);
1011                                 nameAndTypeIndex = literalIndexForMethods(literalIndex(aMethodBinding.constantPoolName()), literalIndex(aMethodBinding.signature()), aMethodBinding);
1012                                 index = wellKnownMethods[indexWellKnownMethod] = currentIndex++;
1013                                 if (index > 0xFFFF){
1014                                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
1015                                 }
1016                                 // Write the interface method ref constant into the constant pool
1017                                 // First add the tag
1018                                 writeU1(InterfaceMethodRefTag);
1019                                 // Then write the class index
1020                                 writeU2(classIndex);
1021                                 // The write the nameAndType index
1022                                 writeU2(nameAndTypeIndex);
1023                         } else {
1024                                 // Lookinf into the method ref table
1025                                 classIndex = literalIndex(aMethodBinding.declaringClass);
1026                                 nameAndTypeIndex = literalIndexForMethods(literalIndex(aMethodBinding.constantPoolName()), literalIndex(aMethodBinding.signature()), aMethodBinding);
1027                                 index = wellKnownMethods[indexWellKnownMethod] = currentIndex++;
1028                                 if (index > 0xFFFF){
1029                                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
1030                                 }
1031                                 // Write the method ref constant into the constant pool
1032                                 // First add the tag
1033                                 writeU1(MethodRefTag);
1034                                 // Then write the class index
1035                                 writeU2(classIndex);
1036                                 // The write the nameAndType index
1037                                 writeU2(nameAndTypeIndex);
1038                         }
1039                 }
1040         }
1041         return index;
1042 }
1043 /**
1044  * This method returns the index into the constantPool corresponding to the type descriptor.
1045  *
1046  * @param TypeBinding aTypeBinding
1047  * @return <CODE>int</CODE>
1048  */
1049 public int literalIndex(TypeBinding aTypeBinding) {
1050         int index;
1051         int nameIndex;
1052         int indexWellKnownType;
1053         if ((indexWellKnownType = indexOfWellKnownTypes(aTypeBinding)) == -1) {
1054                 if ((index = classCache.get(aTypeBinding)) < 0) {
1055                         // The entry doesn't exit yet
1056                         nameIndex = literalIndex(aTypeBinding.constantPoolName());
1057                         index = classCache.put(aTypeBinding, currentIndex++);
1058                         if (index > 0xFFFF){
1059                                 this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
1060                         }
1061                         writeU1(ClassTag);
1062                         // Then add the 8 bytes representing the long
1063                         writeU2(nameIndex);
1064                 }
1065         } else {
1066                 if ((index = wellKnownTypes[indexWellKnownType]) == 0) {
1067                         // Need to insert that binding
1068                         nameIndex = literalIndex(aTypeBinding.constantPoolName());
1069                         index = wellKnownTypes[indexWellKnownType] = currentIndex++;
1070                         if (index > 0xFFFF){
1071                                 this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
1072                         }
1073                         writeU1(ClassTag);
1074                         // Then add the 8 bytes representing the long
1075                         writeU2(nameIndex);
1076                 }
1077         }
1078         return index;
1079 }
1080 /**
1081  * This method returns the index into the constantPool corresponding
1082  * nameAndType constant with nameIndex, typeIndex.
1083  *
1084  * @param int nameIndex
1085  * @param int nameIndex
1086  * @param org.eclipse.jdt.internal.compiler.lookup.FieldBinding a FieldBinding
1087  * @return <CODE>int</CODE>
1088  */
1089 public int literalIndexForFields(int nameIndex, int typeIndex, FieldBinding key) {
1090         int index;
1091         int indexOfWellKnownFieldNameAndType;
1092         if ((indexOfWellKnownFieldNameAndType = indexOfWellKnownFieldNameAndType(key)) == -1) {
1093                 // check if the entry already exists
1094                 if ((index = nameAndTypeCacheForFields.get(key)) == -1) {
1095                         // The entry doesn't exit yet
1096                         index = nameAndTypeCacheForFields.put(key, currentIndex++);
1097                         if (index > 0xFFFF){
1098                                 this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
1099                         }
1100                         writeU1(NameAndTypeTag);
1101                         writeU2(nameIndex);
1102                         writeU2(typeIndex);
1103                 }
1104         } else {
1105                 if ((index = wellKnownFieldNameAndTypes[indexOfWellKnownFieldNameAndType]) == 0) {
1106                         index = wellKnownFieldNameAndTypes[indexOfWellKnownFieldNameAndType] = currentIndex++;
1107                         if (index > 0xFFFF){
1108                                 this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
1109                         }
1110                         writeU1(NameAndTypeTag);
1111                         writeU2(nameIndex);
1112                         writeU2(typeIndex);
1113                 }
1114         }
1115         return index;
1116 }
1117 /**
1118  * This method returns the index into the constantPool corresponding to the type descriptor.
1119  *
1120  * @param TypeBinding aTypeBinding
1121  * @return <CODE>int</CODE>
1122  */
1123 public int literalIndexForJavaLangBoolean() {
1124         int index;
1125         if ((index = wellKnownTypes[JAVA_LANG_BOOLEAN_TYPE]) == 0) {
1126                 int nameIndex;
1127                 // The entry doesn't exit yet
1128                 nameIndex = literalIndex(QualifiedNamesConstants.JavaLangBooleanConstantPoolName);
1129                 index = wellKnownTypes[JAVA_LANG_BOOLEAN_TYPE] = currentIndex++;
1130                 if (index > 0xFFFF){
1131                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
1132                 }
1133                 writeU1(ClassTag);
1134                 // Then add the 8 bytes representing the long
1135                 writeU2(nameIndex);
1136         }
1137         return index;
1138 }
1139 /**
1140  * This method returns the index into the constantPool
1141  * corresponding to the field binding aFieldBinding.
1142  *
1143  * @return <CODE>int</CODE>
1144  */
1145 public int literalIndexForJavaLangBooleanTYPE() {
1146         int index;
1147         if ((index = wellKnownFields[TYPE_BOOLEAN_FIELD]) == 0) {
1148                 int nameAndTypeIndex;
1149                 int classIndex;
1150                 // The entry doesn't exit yet
1151                 classIndex = literalIndexForJavaLangBoolean();
1152                 if ((nameAndTypeIndex = wellKnownFieldNameAndTypes[TYPE_JAVALANGCLASS_NAME_AND_TYPE]) == 0) {
1153                         int nameIndex = literalIndex(QualifiedNamesConstants.TYPE);
1154                         int typeIndex = literalIndex(QualifiedNamesConstants.JavaLangClassSignature);
1155                         nameAndTypeIndex = wellKnownFieldNameAndTypes[TYPE_JAVALANGCLASS_NAME_AND_TYPE] = currentIndex++;
1156                         writeU1(NameAndTypeTag);
1157                         writeU2(nameIndex);
1158                         writeU2(typeIndex);
1159                 }
1160                 index = wellKnownFields[TYPE_BOOLEAN_FIELD] = currentIndex++;
1161                 if (index > 0xFFFF){
1162                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
1163                 }
1164                 writeU1(FieldRefTag);
1165                 writeU2(classIndex);
1166                 writeU2(nameAndTypeIndex);
1167         }
1168         return index;
1169 }
1170 /**
1171  * This method returns the index into the constantPool corresponding to the type descriptor.
1172  *
1173  * @param TypeBinding aTypeBinding
1174  * @return <CODE>int</CODE>
1175  */
1176 public int literalIndexForJavaLangByte() {
1177         int index;
1178         if ((index = wellKnownTypes[JAVA_LANG_BYTE_TYPE]) == 0) {
1179                 int nameIndex;
1180                 // The entry doesn't exit yet
1181                 nameIndex = literalIndex(QualifiedNamesConstants.JavaLangByteConstantPoolName);
1182                 index = wellKnownTypes[JAVA_LANG_BYTE_TYPE] = currentIndex++;
1183                 if (index > 0xFFFF){
1184                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
1185                 }
1186                 writeU1(ClassTag);
1187                 // Then add the 8 bytes representing the long
1188                 writeU2(nameIndex);
1189         }
1190         return index;
1191 }
1192 /**
1193  * This method returns the index into the constantPool
1194  * corresponding to the field binding aFieldBinding.
1195  *
1196  * @return <CODE>int</CODE>
1197  */
1198 public int literalIndexForJavaLangByteTYPE() {
1199         int index;
1200         if ((index = wellKnownFields[TYPE_BYTE_FIELD]) == 0) {
1201                 int nameAndTypeIndex;
1202                 int classIndex;
1203                 // The entry doesn't exit yet
1204                 classIndex = literalIndexForJavaLangByte();
1205                 if ((nameAndTypeIndex = wellKnownFieldNameAndTypes[TYPE_JAVALANGCLASS_NAME_AND_TYPE]) == 0) {
1206                         int nameIndex = literalIndex(QualifiedNamesConstants.TYPE);
1207                         int typeIndex = literalIndex(QualifiedNamesConstants.JavaLangClassSignature);
1208                         nameAndTypeIndex = wellKnownFieldNameAndTypes[TYPE_JAVALANGCLASS_NAME_AND_TYPE] = currentIndex++;
1209                         writeU1(NameAndTypeTag);
1210                         writeU2(nameIndex);
1211                         writeU2(typeIndex);
1212                 }
1213                 index = wellKnownFields[TYPE_BYTE_FIELD] = currentIndex++;
1214                 if (index > 0xFFFF){
1215                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
1216                 }
1217                 writeU1(FieldRefTag);
1218                 writeU2(classIndex);
1219                 writeU2(nameAndTypeIndex);
1220         }
1221         return index;
1222 }
1223 /**
1224  * This method returns the index into the constantPool corresponding to the type descriptor.
1225  *
1226  * @param TypeBinding aTypeBinding
1227  * @return <CODE>int</CODE>
1228  */
1229 public int literalIndexForJavaLangCharacter() {
1230         int index;
1231         if ((index = wellKnownTypes[JAVA_LANG_CHARACTER_TYPE]) == 0) {
1232                 int nameIndex;
1233                 // The entry doesn't exit yet
1234                 nameIndex = literalIndex(QualifiedNamesConstants.JavaLangCharacterConstantPoolName);
1235                 index = wellKnownTypes[JAVA_LANG_CHARACTER_TYPE] = currentIndex++;
1236                 if (index > 0xFFFF){
1237                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
1238                 }
1239                 writeU1(ClassTag);
1240                 // Then add the 8 bytes representing the long
1241                 writeU2(nameIndex);
1242         }
1243         return index;
1244 }
1245 /**
1246  * This method returns the index into the constantPool
1247  * corresponding to the field binding aFieldBinding.
1248  *
1249  * @return <CODE>int</CODE>
1250  */
1251 public int literalIndexForJavaLangCharacterTYPE() {
1252         int index;
1253         if ((index = wellKnownFields[TYPE_CHARACTER_FIELD]) == 0) {
1254                 int nameAndTypeIndex;
1255                 int classIndex;
1256                 // The entry doesn't exit yet
1257                 classIndex = literalIndexForJavaLangCharacter();
1258                 if ((nameAndTypeIndex = wellKnownFieldNameAndTypes[TYPE_JAVALANGCLASS_NAME_AND_TYPE]) == 0) {
1259                         int nameIndex = literalIndex(QualifiedNamesConstants.TYPE);
1260                         int typeIndex = literalIndex(QualifiedNamesConstants.JavaLangClassSignature);
1261                         nameAndTypeIndex = wellKnownFieldNameAndTypes[TYPE_JAVALANGCLASS_NAME_AND_TYPE] = currentIndex++;
1262                         writeU1(NameAndTypeTag);
1263                         writeU2(nameIndex);
1264                         writeU2(typeIndex);
1265                 }
1266                 index = wellKnownFields[TYPE_CHARACTER_FIELD] = currentIndex++;
1267                 if (index > 0xFFFF){
1268                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
1269                 }
1270                 writeU1(FieldRefTag);
1271                 writeU2(classIndex);
1272                 writeU2(nameAndTypeIndex);
1273         }
1274         return index;
1275 }
1276 /**
1277  * This method returns the index into the constantPool corresponding to the type descriptor.
1278  *
1279  * @param TypeBinding aTypeBinding
1280  * @return <CODE>int</CODE>
1281  */
1282 public int literalIndexForJavaLangClass() {
1283         int index;
1284         if ((index = wellKnownTypes[JAVA_LANG_CLASS_TYPE]) == 0) {
1285                 int nameIndex;
1286                 // The entry doesn't exit yet
1287                 nameIndex = literalIndex(QualifiedNamesConstants.JavaLangClassConstantPoolName);
1288                 index = wellKnownTypes[JAVA_LANG_CLASS_TYPE] = currentIndex++;
1289                 if (index > 0xFFFF){
1290                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
1291                 }
1292                 writeU1(ClassTag);
1293                 // Then add the 8 bytes representing the long
1294                 writeU2(nameIndex);
1295         }
1296         return index;
1297 }
1298 /**
1299  * This method returns the index into the constantPool corresponding to the
1300  * method descriptor. It can be either an interface method reference constant
1301  * or a method reference constant.
1302  *
1303  * @return <CODE>int</CODE>
1304  */
1305 public int literalIndexForJavaLangClassForName() {
1306         int index;
1307         int nameAndTypeIndex;
1308         int classIndex;
1309         // Looking into the method ref table
1310         if ((index = wellKnownMethods[FORNAME_CLASS_METHOD]) == 0) {
1311                 classIndex = literalIndexForJavaLangClass();
1312                 if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[FORNAME_CLASS_METHOD_NAME_AND_TYPE]) == 0) {
1313                         int nameIndex = literalIndex(QualifiedNamesConstants.ForName);
1314                         int typeIndex = literalIndex(QualifiedNamesConstants.ForNameSignature);
1315                         nameAndTypeIndex = wellKnownMethodNameAndTypes[FORNAME_CLASS_METHOD_NAME_AND_TYPE] = currentIndex++;
1316                         writeU1(NameAndTypeTag);
1317                         writeU2(nameIndex);
1318                         writeU2(typeIndex);
1319                 }
1320                 index = wellKnownMethods[FORNAME_CLASS_METHOD] = currentIndex++;
1321                 if (index > 0xFFFF){
1322                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
1323                 }
1324                 // Write the method ref constant into the constant pool
1325                 // First add the tag
1326                 writeU1(MethodRefTag);
1327                 // Then write the class index
1328                 writeU2(classIndex);
1329                 // The write the nameAndType index
1330                 writeU2(nameAndTypeIndex);
1331         }
1332         return index;
1333 }
1334 /**
1335  * This method returns the index into the constantPool corresponding to the
1336  * method descriptor. It can be either an interface method reference constant
1337  * or a method reference constant.
1338  *
1339  * @return <CODE>int</CODE>
1340  */
1341 public int literalIndexForJavaLangClassGetConstructor() {
1342         int index;
1343         int nameAndTypeIndex;
1344         int classIndex;
1345         // Looking into the method ref table
1346         if ((index = wellKnownMethods[GETCONSTRUCTOR_CLASS_METHOD]) == 0) {
1347                 classIndex = literalIndexForJavaLangClass();
1348                 if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[GETCONSTRUCTOR_METHOD_NAME_AND_TYPE]) == 0) {
1349                         int nameIndex = literalIndex(QualifiedNamesConstants.GetConstructor);
1350                         int typeIndex = literalIndex(QualifiedNamesConstants.GetConstructorSignature);
1351                         nameAndTypeIndex = wellKnownMethodNameAndTypes[GETCONSTRUCTOR_METHOD_NAME_AND_TYPE] = currentIndex++;
1352                         writeU1(NameAndTypeTag);
1353                         writeU2(nameIndex);
1354                         writeU2(typeIndex);
1355                 }
1356                 index = wellKnownMethods[GETCONSTRUCTOR_CLASS_METHOD] = currentIndex++;
1357                 if (index > 0xFFFF){
1358                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
1359                 }
1360                 // Write the method ref constant into the constant pool
1361                 // First add the tag
1362                 writeU1(MethodRefTag);
1363                 // Then write the class index
1364                 writeU2(classIndex);
1365                 // The write the nameAndType index
1366                 writeU2(nameAndTypeIndex);
1367         }
1368         return index;
1369 }
1370 /**
1371  * This method returns the index into the constantPool corresponding to the
1372  * method descriptor. It can be either an interface method reference constant
1373  * or a method reference constant.
1374  *
1375  * @return <CODE>int</CODE>
1376  */
1377 public int literalIndexForJavaLangClassDesiredAssertionStatus() {
1378         int index;
1379         int nameAndTypeIndex;
1380         int classIndex;
1381         // Looking into the method ref table
1382         if ((index = wellKnownMethods[DESIREDASSERTIONSTATUS_CLASS_METHOD]) == 0) {
1383                 classIndex = literalIndexForJavaLangClass();
1384                 if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[DESIREDASSERTIONSTATUS_METHOD_NAME_AND_TYPE]) == 0) {
1385                         int nameIndex = literalIndex(QualifiedNamesConstants.DesiredAssertionStatus);
1386                         int typeIndex = literalIndex(QualifiedNamesConstants.DesiredAssertionStatusSignature);
1387                         nameAndTypeIndex = wellKnownMethodNameAndTypes[DESIREDASSERTIONSTATUS_METHOD_NAME_AND_TYPE] = currentIndex++;
1388                         writeU1(NameAndTypeTag);
1389                         writeU2(nameIndex);
1390                         writeU2(typeIndex);
1391                 }
1392                 index = wellKnownMethods[DESIREDASSERTIONSTATUS_CLASS_METHOD] = currentIndex++;
1393                 if (index > 0xFFFF){
1394                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
1395                 }
1396                 // Write the method ref constant into the constant pool
1397                 // First add the tag
1398                 writeU1(MethodRefTag);
1399                 // Then write the class index
1400                 writeU2(classIndex);
1401                 // The write the nameAndType index
1402                 writeU2(nameAndTypeIndex);
1403         }
1404         return index;
1405 }
1406 /**
1407  * This method returns the index into the constantPool corresponding to the type descriptor.
1408  *
1409  * @param TypeBinding aTypeBinding
1410  * @return <CODE>int</CODE>
1411  */
1412 public int literalIndexForJavaLangClassNotFoundException() {
1413         int index;
1414         if ((index = wellKnownTypes[JAVA_LANG_CLASSNOTFOUNDEXCEPTION_TYPE]) == 0) {
1415                 int nameIndex;
1416                 // The entry doesn't exit yet
1417                 nameIndex = literalIndex(QualifiedNamesConstants.JavaLangClassNotFoundExceptionConstantPoolName);
1418                 index = wellKnownTypes[JAVA_LANG_CLASSNOTFOUNDEXCEPTION_TYPE] = currentIndex++;
1419                 if (index > 0xFFFF){
1420                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
1421                 }
1422                 writeU1(ClassTag);
1423                 // Then add the 8 bytes representing the long
1424                 writeU2(nameIndex);
1425         }
1426         return index;
1427 }
1428 /**
1429  * This method returns the index into the constantPool corresponding to the type descriptor.
1430  *
1431  * @param TypeBinding aTypeBinding
1432  * @return <CODE>int</CODE>
1433  */
1434 public int literalIndexForJavaLangDouble() {
1435         int index;
1436         if ((index = wellKnownTypes[JAVA_LANG_DOUBLE_TYPE]) == 0) {
1437                 int nameIndex;
1438                 // The entry doesn't exit yet
1439                 nameIndex = literalIndex(QualifiedNamesConstants.JavaLangDoubleConstantPoolName);
1440                 index = wellKnownTypes[JAVA_LANG_DOUBLE_TYPE] = currentIndex++;
1441                 if (index > 0xFFFF){
1442                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
1443                 }
1444                 writeU1(ClassTag);
1445                 // Then add the 8 bytes representing the long
1446                 writeU2(nameIndex);
1447         }
1448         return index;
1449 }
1450 /**
1451  * This method returns the index into the constantPool
1452  * corresponding to the field binding aFieldBinding.
1453  *
1454  * @return <CODE>int</CODE>
1455  */
1456 public int literalIndexForJavaLangDoubleTYPE() {
1457         int index;
1458         if ((index = wellKnownFields[TYPE_DOUBLE_FIELD]) == 0) {
1459                 int nameAndTypeIndex;
1460                 int classIndex;
1461                 // The entry doesn't exit yet
1462                 classIndex = literalIndexForJavaLangDouble();
1463                 if ((nameAndTypeIndex = wellKnownFieldNameAndTypes[TYPE_JAVALANGCLASS_NAME_AND_TYPE]) == 0) {
1464                         int nameIndex = literalIndex(QualifiedNamesConstants.TYPE);
1465                         int typeIndex = literalIndex(QualifiedNamesConstants.JavaLangClassSignature);
1466                         nameAndTypeIndex = wellKnownFieldNameAndTypes[TYPE_JAVALANGCLASS_NAME_AND_TYPE] = currentIndex++;
1467                         writeU1(NameAndTypeTag);
1468                         writeU2(nameIndex);
1469                         writeU2(typeIndex);
1470                 }
1471                 index = wellKnownFields[TYPE_DOUBLE_FIELD] = currentIndex++;
1472                 if (index > 0xFFFF){
1473                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
1474                 }
1475                 writeU1(FieldRefTag);
1476                 writeU2(classIndex);
1477                 writeU2(nameAndTypeIndex);
1478         }
1479         return index;
1480 }
1481 /**
1482  * This method returns the index into the constantPool corresponding to the type descriptor.
1483  *
1484  * @param TypeBinding aTypeBinding
1485  * @return <CODE>int</CODE>
1486  */
1487 public int literalIndexForJavaLangError() {
1488         int index;
1489         if ((index = wellKnownTypes[JAVA_LANG_ERROR_TYPE]) == 0) {
1490                 int nameIndex;
1491                 // The entry doesn't exit yet
1492                 nameIndex = literalIndex(QualifiedNamesConstants.JavaLangErrorConstantPoolName);
1493                 index = wellKnownTypes[JAVA_LANG_ERROR_TYPE] = currentIndex++;
1494                 if (index > 0xFFFF){
1495                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
1496                 }
1497                 writeU1(ClassTag);
1498                 // Then add the 8 bytes representing the long
1499                 writeU2(nameIndex);
1500         }
1501         return index;
1502 }
1503 /**
1504  * This method returns the index into the constantPool corresponding to the
1505  * method descriptor. It can be either an interface method reference constant
1506  * or a method reference constant.
1507  *
1508  * @return <CODE>int</CODE>
1509  */
1510 public int literalIndexForJavaLangErrorConstructor() {
1511         int index;
1512         int nameAndTypeIndex;
1513         int classIndex;
1514         // Looking into the method ref table
1515         if ((index = wellKnownMethods[JAVALANGERROR_CONSTR_METHOD]) == 0) {
1516                 classIndex = literalIndexForJavaLangError();
1517                 if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[CONSTR_STRING_METHOD_NAME_AND_TYPE]) == 0) {
1518                         int nameIndex = literalIndex(QualifiedNamesConstants.Init);
1519                         int typeIndex = literalIndex(QualifiedNamesConstants.StringConstructorSignature);
1520                         nameAndTypeIndex = wellKnownMethodNameAndTypes[CONSTR_STRING_METHOD_NAME_AND_TYPE] = currentIndex++;
1521                         writeU1(NameAndTypeTag);
1522                         writeU2(nameIndex);
1523                         writeU2(typeIndex);
1524                 }
1525                 index = wellKnownMethods[JAVALANGERROR_CONSTR_METHOD] = currentIndex++;
1526                 if (index > 0xFFFF){
1527                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
1528                 }
1529                 // Write the method ref constant into the constant pool
1530                 // First add the tag
1531                 writeU1(MethodRefTag);
1532                 // Then write the class index
1533                 writeU2(classIndex);
1534                 // The write the nameAndType index
1535                 writeU2(nameAndTypeIndex);
1536         }
1537         return index;
1538 }
1539 public int literalIndexForJavaLangException() {
1540         int index;
1541         if ((index = wellKnownTypes[JAVA_LANG_EXCEPTION_TYPE]) == 0) {
1542                 // The entry doesn't exit yet
1543                 int nameIndex = literalIndex(QualifiedNamesConstants.JavaLangExceptionConstantPoolName);
1544                 index = wellKnownTypes[JAVA_LANG_EXCEPTION_TYPE] = currentIndex++;
1545                 if (index > 0xFFFF){
1546                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
1547                 }
1548                 writeU1(ClassTag);
1549                 // Then add the 8 bytes representing the long
1550                 writeU2(nameIndex);
1551         }
1552         return index;
1553 }
1554 /**
1555  * This method returns the index into the constantPool corresponding to the type descriptor.
1556  *
1557  * @param TypeBinding aTypeBinding
1558  * @return <CODE>int</CODE>
1559  */
1560 public int literalIndexForJavaLangFloat() {
1561         int index;
1562         if ((index = wellKnownTypes[JAVA_LANG_FLOAT_TYPE]) == 0) {
1563                 int nameIndex;
1564                 // The entry doesn't exit yet
1565                 nameIndex = literalIndex(QualifiedNamesConstants.JavaLangFloatConstantPoolName);
1566                 index = wellKnownTypes[JAVA_LANG_FLOAT_TYPE] = currentIndex++;
1567                 if (index > 0xFFFF){
1568                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
1569                 }
1570                 writeU1(ClassTag);
1571                 // Then add the 8 bytes representing the long
1572                 writeU2(nameIndex);
1573         }
1574         return index;
1575 }
1576 /**
1577  * This method returns the index into the constantPool
1578  * corresponding to the field binding aFieldBinding.
1579  *
1580  * @return <CODE>int</CODE>
1581  */
1582 public int literalIndexForJavaLangFloatTYPE() {
1583         int index;
1584         if ((index = wellKnownFields[TYPE_FLOAT_FIELD]) == 0) {
1585                 int nameAndTypeIndex;
1586                 int classIndex;
1587                 // The entry doesn't exit yet
1588                 classIndex = literalIndexForJavaLangFloat();
1589                 if ((nameAndTypeIndex = wellKnownFieldNameAndTypes[TYPE_JAVALANGCLASS_NAME_AND_TYPE]) == 0) {
1590                         int nameIndex = literalIndex(QualifiedNamesConstants.TYPE);
1591                         int typeIndex = literalIndex(QualifiedNamesConstants.JavaLangClassSignature);
1592                         nameAndTypeIndex = wellKnownFieldNameAndTypes[TYPE_JAVALANGCLASS_NAME_AND_TYPE] = currentIndex++;
1593                         writeU1(NameAndTypeTag);
1594                         writeU2(nameIndex);
1595                         writeU2(typeIndex);
1596                 }
1597                 index = wellKnownFields[TYPE_FLOAT_FIELD] = currentIndex++;
1598                 if (index > 0xFFFF){
1599                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
1600                 }
1601                 writeU1(FieldRefTag);
1602                 writeU2(classIndex);
1603                 writeU2(nameAndTypeIndex);
1604         }
1605         return index;
1606 }
1607 /**
1608  * This method returns the index into the constantPool corresponding to the type descriptor.
1609  *
1610  * @param TypeBinding aTypeBinding
1611  * @return <CODE>int</CODE>
1612  */
1613 public int literalIndexForJavaLangInteger() {
1614         int index;
1615         if ((index = wellKnownTypes[JAVA_LANG_INTEGER_TYPE]) == 0) {
1616                 int nameIndex;
1617                 // The entry doesn't exit yet
1618                 nameIndex = literalIndex(QualifiedNamesConstants.JavaLangIntegerConstantPoolName);
1619                 index = wellKnownTypes[JAVA_LANG_INTEGER_TYPE] = currentIndex++;
1620                 if (index > 0xFFFF){
1621                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
1622                 }
1623                 writeU1(ClassTag);
1624                 // Then add the 8 bytes representing the long
1625                 writeU2(nameIndex);
1626         }
1627         return index;
1628 }
1629 /**
1630  * This method returns the index into the constantPool
1631  * corresponding to the field binding aFieldBinding.
1632  *
1633  * @return <CODE>int</CODE>
1634  */
1635 public int literalIndexForJavaLangIntegerTYPE() {
1636         int index;
1637         if ((index = wellKnownFields[TYPE_INTEGER_FIELD]) == 0) {
1638                 int nameAndTypeIndex;
1639                 int classIndex;
1640                 // The entry doesn't exit yet
1641                 classIndex = literalIndexForJavaLangInteger();
1642                 if ((nameAndTypeIndex = wellKnownFieldNameAndTypes[TYPE_JAVALANGCLASS_NAME_AND_TYPE]) == 0) {
1643                         int nameIndex = literalIndex(QualifiedNamesConstants.TYPE);
1644                         int typeIndex = literalIndex(QualifiedNamesConstants.JavaLangClassSignature);
1645                         nameAndTypeIndex = wellKnownFieldNameAndTypes[TYPE_JAVALANGCLASS_NAME_AND_TYPE] = currentIndex++;
1646                         writeU1(NameAndTypeTag);
1647                         writeU2(nameIndex);
1648                         writeU2(typeIndex);
1649                 }
1650                 index = wellKnownFields[TYPE_INTEGER_FIELD] = currentIndex++;
1651                 if (index > 0xFFFF){
1652                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
1653                 }
1654                 writeU1(FieldRefTag);
1655                 writeU2(classIndex);
1656                 writeU2(nameAndTypeIndex);
1657         }
1658         return index;
1659 }
1660 /**
1661  * This method returns the index into the constantPool corresponding to the type descriptor.
1662  *
1663  * @param TypeBinding aTypeBinding
1664  * @return <CODE>int</CODE>
1665  */
1666 public int literalIndexForJavaLangLong() {
1667         int index;
1668         if ((index = wellKnownTypes[JAVA_LANG_LONG_TYPE]) == 0) {
1669                 int nameIndex;
1670                 // The entry doesn't exit yet
1671                 nameIndex = literalIndex(QualifiedNamesConstants.JavaLangLongConstantPoolName);
1672                 index = wellKnownTypes[JAVA_LANG_LONG_TYPE] = currentIndex++;
1673                 if (index > 0xFFFF){
1674                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
1675                 }
1676                 writeU1(ClassTag);
1677                 // Then add the 8 bytes representing the long
1678                 writeU2(nameIndex);
1679         }
1680         return index;
1681 }
1682 /**
1683  * This method returns the index into the constantPool
1684  * corresponding to the field binding aFieldBinding.
1685  *
1686  * @return <CODE>int</CODE>
1687  */
1688 public int literalIndexForJavaLangLongTYPE() {
1689         int index;
1690         if ((index = wellKnownFields[TYPE_LONG_FIELD]) == 0) {
1691                 int nameAndTypeIndex;
1692                 int classIndex;
1693                 // The entry doesn't exit yet
1694                 classIndex = literalIndexForJavaLangLong();
1695                 if ((nameAndTypeIndex = wellKnownFieldNameAndTypes[TYPE_JAVALANGCLASS_NAME_AND_TYPE]) == 0) {
1696                         int nameIndex = literalIndex(QualifiedNamesConstants.TYPE);
1697                         int typeIndex = literalIndex(QualifiedNamesConstants.JavaLangClassSignature);
1698                         nameAndTypeIndex = wellKnownFieldNameAndTypes[TYPE_JAVALANGCLASS_NAME_AND_TYPE] = currentIndex++;
1699                         writeU1(NameAndTypeTag);
1700                         writeU2(nameIndex);
1701                         writeU2(typeIndex);
1702                 }
1703                 index = wellKnownFields[TYPE_LONG_FIELD] = currentIndex++;
1704                 if (index > 0xFFFF){
1705                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
1706                 }
1707                 writeU1(FieldRefTag);
1708                 writeU2(classIndex);
1709                 writeU2(nameAndTypeIndex);
1710         }
1711         return index;
1712 }
1713 /**
1714  * This method returns the index into the constantPool corresponding to the type descriptor.
1715  *
1716  * @param TypeBinding aTypeBinding
1717  * @return <CODE>int</CODE>
1718  */
1719 public int literalIndexForJavaLangNoClassDefFoundError() {
1720         int index;
1721         if ((index = wellKnownTypes[JAVA_LANG_NOCLASSDEFFOUNDERROR_TYPE]) == 0) {
1722                 int nameIndex;
1723                 // The entry doesn't exit yet
1724                 nameIndex = literalIndex(QualifiedNamesConstants.JavaLangNoClassDefFoundErrorConstantPoolName);
1725                 index = wellKnownTypes[JAVA_LANG_NOCLASSDEFFOUNDERROR_TYPE] = currentIndex++;
1726                 if (index > 0xFFFF){
1727                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
1728                 }
1729                 writeU1(ClassTag);
1730                 // Then add the 8 bytes representing the long
1731                 writeU2(nameIndex);
1732         }
1733         return index;
1734 }
1735
1736 /**
1737  * This method returns the index into the constantPool corresponding to the type descriptor.
1738  *
1739  * @param TypeBinding aTypeBinding
1740  * @return <CODE>int</CODE>
1741  */
1742 public int literalIndexForJavaLangAssertionError() {
1743         int index;
1744         if ((index = wellKnownTypes[JAVA_LANG_ASSERTIONERROR_TYPE]) == 0) {
1745                 int nameIndex;
1746                 // The entry doesn't exit yet
1747                 nameIndex = literalIndex(QualifiedNamesConstants.JavaLangAssertionErrorConstantPoolName);
1748                 index = wellKnownTypes[JAVA_LANG_ASSERTIONERROR_TYPE] = currentIndex++;
1749                 if (index > 0xFFFF){
1750                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
1751                 }
1752                 writeU1(ClassTag);
1753                 // Then add the 8 bytes representing the long
1754                 writeU2(nameIndex);
1755         }
1756         return index;
1757 }
1758
1759 /**
1760  * This method returns the index into the constantPool corresponding to the type descriptor.
1761  *
1762  * @param TypeBinding aTypeBinding
1763  * @return <CODE>int</CODE>
1764  */
1765 public int literalIndexForJavaLangAssertionErrorConstructor(int typeBindingID) {
1766         int index = 0;
1767         int nameAndTypeIndex = 0;
1768         int classIndex = 0;
1769         switch (typeBindingID) {
1770                 case T_int :
1771                 case T_byte :
1772                 case T_short :
1773                         if ((index = wellKnownMethods[ASSERTIONERROR_CONSTR_INT_METHOD]) == 0) {
1774                                 classIndex = literalIndexForJavaLangAssertionError();
1775                                 if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[CONSTR_INT_METHOD_NAME_AND_TYPE]) == 0) {
1776                                         int nameIndex = literalIndex(QualifiedNamesConstants.Init);
1777                                         int typeIndex = literalIndex(QualifiedNamesConstants.AssertionErrorIntConstrSignature);
1778                                         nameAndTypeIndex = wellKnownMethodNameAndTypes[CONSTR_INT_METHOD_NAME_AND_TYPE] = currentIndex++;
1779                                         writeU1(NameAndTypeTag);
1780                                         writeU2(nameIndex);
1781                                         writeU2(typeIndex);
1782                                 }
1783                                 index = wellKnownMethods[ASSERTIONERROR_CONSTR_INT_METHOD] = currentIndex++;
1784                                 if (index > 0xFFFF){
1785                                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
1786                                 }
1787                                 // Write the method ref constant into the constant pool
1788                                 // First add the tag
1789                                 writeU1(MethodRefTag);
1790                                 // Then write the class index
1791                                 writeU2(classIndex);
1792                                 // The write the nameAndType index
1793                                 writeU2(nameAndTypeIndex);
1794                         }
1795                         break;
1796                 case T_long :
1797                         if ((index = wellKnownMethods[ASSERTIONERROR_CONSTR_LONG_METHOD]) == 0) {
1798                                 classIndex = literalIndexForJavaLangAssertionError();
1799                                 if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[CONSTR_LONG_METHOD_NAME_AND_TYPE]) == 0) {
1800                                         int nameIndex = literalIndex(QualifiedNamesConstants.Init);
1801                                         int typeIndex = literalIndex(QualifiedNamesConstants.AssertionErrorLongConstrSignature);
1802                                         nameAndTypeIndex = wellKnownMethodNameAndTypes[CONSTR_LONG_METHOD_NAME_AND_TYPE] = currentIndex++;
1803                                         writeU1(NameAndTypeTag);
1804                                         writeU2(nameIndex);
1805                                         writeU2(typeIndex);
1806                                 }
1807                                 index = wellKnownMethods[ASSERTIONERROR_CONSTR_LONG_METHOD] = currentIndex++;
1808                                 if (index > 0xFFFF){
1809                                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
1810                                 }
1811                                 // Write the method ref constant into the constant pool
1812                                 // First add the tag
1813                                 writeU1(MethodRefTag);
1814                                 // Then write the class index
1815                                 writeU2(classIndex);
1816                                 // The write the nameAndType index
1817                                 writeU2(nameAndTypeIndex);
1818                         }
1819                         break;
1820                 case T_float :
1821                         if ((index = wellKnownMethods[ASSERTIONERROR_CONSTR_FLOAT_METHOD]) == 0) {
1822                                 classIndex = literalIndexForJavaLangAssertionError();
1823                                 if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[CONSTR_FLOAT_METHOD_NAME_AND_TYPE]) == 0) {
1824                                         int nameIndex = literalIndex(QualifiedNamesConstants.Init);
1825                                         int typeIndex = literalIndex(QualifiedNamesConstants.AssertionErrorFloatConstrSignature);
1826                                         nameAndTypeIndex = wellKnownMethodNameAndTypes[CONSTR_FLOAT_METHOD_NAME_AND_TYPE] = currentIndex++;
1827                                         writeU1(NameAndTypeTag);
1828                                         writeU2(nameIndex);
1829                                         writeU2(typeIndex);
1830                                 }
1831                                 index = wellKnownMethods[ASSERTIONERROR_CONSTR_FLOAT_METHOD] = currentIndex++;
1832                                 if (index > 0xFFFF){
1833                                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
1834                                 }
1835                                 // Write the method ref constant into the constant pool
1836                                 // First add the tag
1837                                 writeU1(MethodRefTag);
1838                                 // Then write the class index
1839                                 writeU2(classIndex);
1840                                 // The write the nameAndType index
1841                                 writeU2(nameAndTypeIndex);
1842                         }
1843                         break;
1844                 case T_double :
1845                         if ((index = wellKnownMethods[ASSERTIONERROR_CONSTR_DOUBLE_METHOD]) == 0) {
1846                                 classIndex = literalIndexForJavaLangAssertionError();
1847                                 if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[CONSTR_DOUBLE_METHOD_NAME_AND_TYPE]) == 0) {
1848                                         int nameIndex = literalIndex(QualifiedNamesConstants.Init);
1849                                         int typeIndex = literalIndex(QualifiedNamesConstants.AssertionErrorDoubleConstrSignature);
1850                                         nameAndTypeIndex = wellKnownMethodNameAndTypes[CONSTR_DOUBLE_METHOD_NAME_AND_TYPE] = currentIndex++;
1851                                         writeU1(NameAndTypeTag);
1852                                         writeU2(nameIndex);
1853                                         writeU2(typeIndex);
1854                                 }
1855                                 index = wellKnownMethods[ASSERTIONERROR_CONSTR_DOUBLE_METHOD] = currentIndex++;
1856                                 if (index > 0xFFFF){
1857                                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
1858                                 }
1859                                 // Write the method ref constant into the constant pool
1860                                 // First add the tag
1861                                 writeU1(MethodRefTag);
1862                                 // Then write the class index
1863                                 writeU2(classIndex);
1864                                 // The write the nameAndType index
1865                                 writeU2(nameAndTypeIndex);
1866                         }
1867                         break;
1868                 case T_char :
1869                         if ((index = wellKnownMethods[ASSERTIONERROR_CONSTR_CHAR_METHOD]) == 0) {
1870                                 classIndex = literalIndexForJavaLangAssertionError();
1871                                 if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[CONSTR_CHAR_METHOD_NAME_AND_TYPE]) == 0) {
1872                                         int nameIndex = literalIndex(QualifiedNamesConstants.Init);
1873                                         int typeIndex = literalIndex(QualifiedNamesConstants.AssertionErrorCharConstrSignature);
1874                                         nameAndTypeIndex = wellKnownMethodNameAndTypes[CONSTR_CHAR_METHOD_NAME_AND_TYPE] = currentIndex++;
1875                                         writeU1(NameAndTypeTag);
1876                                         writeU2(nameIndex);
1877                                         writeU2(typeIndex);
1878                                 }
1879                                 index = wellKnownMethods[ASSERTIONERROR_CONSTR_CHAR_METHOD] = currentIndex++;
1880                                 if (index > 0xFFFF){
1881                                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
1882                                 }
1883                                 // Write the method ref constant into the constant pool
1884                                 // First add the tag
1885                                 writeU1(MethodRefTag);
1886                                 // Then write the class index
1887                                 writeU2(classIndex);
1888                                 // The write the nameAndType index
1889                                 writeU2(nameAndTypeIndex);
1890                         }
1891                         break;
1892                 case T_boolean :
1893                         if ((index = wellKnownMethods[ASSERTIONERROR_CONSTR_BOOLEAN_METHOD]) == 0) {
1894                                 classIndex = literalIndexForJavaLangAssertionError();
1895                                 if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[CONSTR_BOOLEAN_METHOD_NAME_AND_TYPE]) == 0) {
1896                                         int nameIndex = literalIndex(QualifiedNamesConstants.Init);
1897                                         int typeIndex = literalIndex(QualifiedNamesConstants.AssertionErrorBooleanConstrSignature);
1898                                         nameAndTypeIndex = wellKnownMethodNameAndTypes[CONSTR_BOOLEAN_METHOD_NAME_AND_TYPE] = currentIndex++;
1899                                         writeU1(NameAndTypeTag);
1900                                         writeU2(nameIndex);
1901                                         writeU2(typeIndex);
1902                                 }
1903                                 index = wellKnownMethods[ASSERTIONERROR_CONSTR_BOOLEAN_METHOD] = currentIndex++;
1904                                 if (index > 0xFFFF){
1905                                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
1906                                 }
1907                                 // Write the method ref constant into the constant pool
1908                                 // First add the tag
1909                                 writeU1(MethodRefTag);
1910                                 // Then write the class index
1911                                 writeU2(classIndex);
1912                                 // The write the nameAndType index
1913                                 writeU2(nameAndTypeIndex);
1914                         }
1915                         break;
1916                 //case T_Object :
1917                 //case T_String :
1918                 //case T_null :
1919                 default :
1920                         if ((index = wellKnownMethods[ASSERTIONERROR_CONSTR_OBJECT_METHOD]) == 0) {
1921                                 classIndex = literalIndexForJavaLangAssertionError();
1922                                 if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[CONSTR_OBJECT_METHOD_NAME_AND_TYPE]) == 0) {
1923                                         int nameIndex = literalIndex(QualifiedNamesConstants.Init);
1924                                         int typeIndex = literalIndex(QualifiedNamesConstants.AssertionErrorObjectConstrSignature);
1925                                         nameAndTypeIndex = wellKnownMethodNameAndTypes[CONSTR_OBJECT_METHOD_NAME_AND_TYPE] = currentIndex++;
1926                                         writeU1(NameAndTypeTag);
1927                                         writeU2(nameIndex);
1928                                         writeU2(typeIndex);
1929                                 }
1930                                 index = wellKnownMethods[ASSERTIONERROR_CONSTR_OBJECT_METHOD] = currentIndex++;
1931                                 if (index > 0xFFFF){
1932                                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
1933                                 }
1934                                 // Write the method ref constant into the constant pool
1935                                 // First add the tag
1936                                 writeU1(MethodRefTag);
1937                                 // Then write the class index
1938                                 writeU2(classIndex);
1939                                 // The write the nameAndType index
1940                                 writeU2(nameAndTypeIndex);
1941                         }
1942         }
1943         return index;
1944 }
1945
1946 /**
1947  * This method returns the index into the constantPool corresponding to the
1948  * method descriptor. It can be either an interface method reference constant
1949  * or a method reference constant.
1950  *
1951  * @return <CODE>int</CODE>
1952  */
1953 public int literalIndexForJavaLangAssertionErrorDefaultConstructor() {
1954         int index;
1955         int nameAndTypeIndex;
1956         int classIndex;
1957         // Looking into the method ref table
1958         if ((index = wellKnownMethods[ASSERTIONERROR_DEFAULT_CONSTR_METHOD]) == 0) {
1959                 classIndex = literalIndexForJavaLangAssertionError();
1960                 if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[DEFAULT_CONSTR_METHOD_NAME_AND_TYPE]) == 0) {
1961                         int nameIndex = literalIndex(QualifiedNamesConstants.Init);
1962                         int typeIndex = literalIndex(QualifiedNamesConstants.DefaultConstructorSignature);
1963                         nameAndTypeIndex = wellKnownMethodNameAndTypes[DEFAULT_CONSTR_METHOD_NAME_AND_TYPE] = currentIndex++;
1964                         writeU1(NameAndTypeTag);
1965                         writeU2(nameIndex);
1966                         writeU2(typeIndex);
1967                 }
1968                 index = wellKnownMethods[ASSERTIONERROR_DEFAULT_CONSTR_METHOD] = currentIndex++;
1969                 if (index > 0xFFFF){
1970                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
1971                 }
1972                 // Write the method ref constant into the constant pool
1973                 // First add the tag
1974                 writeU1(MethodRefTag);
1975                 // Then write the class index
1976                 writeU2(classIndex);
1977                 // The write the nameAndType index
1978                 writeU2(nameAndTypeIndex);
1979         }
1980         return index;
1981 }
1982
1983
1984 /**
1985  * This method returns the index into the constantPool corresponding to the
1986  * method descriptor. It can be either an interface method reference constant
1987  * or a method reference constant.
1988  *
1989  * @return <CODE>int</CODE>
1990  */
1991 public int literalIndexForJavaLangNoClassDefFoundErrorStringConstructor() {
1992         int index;
1993         int nameAndTypeIndex;
1994         int classIndex;
1995         // Looking into the method ref table
1996         if ((index = wellKnownMethods[NOCLASSDEFFOUNDERROR_CONSTR_METHOD]) == 0) {
1997                 classIndex = literalIndexForJavaLangNoClassDefFoundError();
1998                 if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[CONSTR_STRING_METHOD_NAME_AND_TYPE]) == 0) {
1999                         int nameIndex = literalIndex(QualifiedNamesConstants.Init);
2000                         int typeIndex = literalIndex(QualifiedNamesConstants.StringConstructorSignature);
2001                         nameAndTypeIndex = wellKnownMethodNameAndTypes[CONSTR_STRING_METHOD_NAME_AND_TYPE] = currentIndex++;
2002                         writeU1(NameAndTypeTag);
2003                         writeU2(nameIndex);
2004                         writeU2(typeIndex);
2005                 }
2006                 index = wellKnownMethods[NOCLASSDEFFOUNDERROR_CONSTR_METHOD] = currentIndex++;
2007                 if (index > 0xFFFF){
2008                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
2009                 }
2010                 // Write the method ref constant into the constant pool
2011                 // First add the tag
2012                 writeU1(MethodRefTag);
2013                 // Then write the class index
2014                 writeU2(classIndex);
2015                 // The write the nameAndType index
2016                 writeU2(nameAndTypeIndex);
2017         }
2018         return index;
2019 }
2020 /**
2021  * This method returns the index into the constantPool corresponding to the type descriptor.
2022  *
2023  * @param TypeBinding aTypeBinding
2024  * @return <CODE>int</CODE>
2025  */
2026 public int literalIndexForJavaLangObject() {
2027         int index;
2028         if ((index = wellKnownTypes[JAVA_LANG_OBJECT_TYPE]) == 0) {
2029                 int nameIndex;
2030                 // The entry doesn't exit yet
2031                 nameIndex = literalIndex(QualifiedNamesConstants.JavaLangObjectConstantPoolName);
2032                 index = wellKnownTypes[JAVA_LANG_OBJECT_TYPE] = currentIndex++;
2033                 if (index > 0xFFFF){
2034                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
2035                 }
2036                 writeU1(ClassTag);
2037                 // Then add the 8 bytes representing the long
2038                 writeU2(nameIndex);
2039         }
2040         return index;
2041 }
2042 /**
2043  * This method returns the index into the constantPool corresponding to the type descriptor.
2044  *
2045  * @param TypeBinding aTypeBinding
2046  * @return <CODE>int</CODE>
2047  */
2048 public int literalIndexForJavaLangReflectConstructor() {
2049         int index;
2050         if ((index = wellKnownTypes[JAVA_LANG_REFLECT_CONSTRUCTOR_TYPE]) == 0) {
2051                 int nameIndex;
2052                 // The entry doesn't exit yet
2053                 nameIndex = literalIndex(QualifiedNamesConstants.JavaLangReflectConstructor);
2054                 index = wellKnownTypes[JAVA_LANG_REFLECT_CONSTRUCTOR_TYPE] = currentIndex++;
2055                 if (index > 0xFFFF){
2056                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
2057                 }
2058                 writeU1(ClassTag);
2059                 // Then add the 8 bytes representing the long
2060                 writeU2(nameIndex);
2061         }
2062         return index;
2063 }
2064 public int literalIndexForJavaLangReflectConstructorNewInstance() {
2065         int index;
2066         int nameAndTypeIndex;
2067         int classIndex;
2068         // Looking into the method ref table
2069         if ((index = wellKnownMethods[NEWINSTANCE_CONSTRUCTOR_METHOD]) == 0) {
2070                 classIndex = literalIndexForJavaLangReflectConstructor();
2071                 if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[NEWINSTANCE_METHOD_NAME_AND_TYPE]) == 0) {
2072                         int nameIndex = literalIndex(QualifiedNamesConstants.NewInstance);
2073                         int typeIndex = literalIndex(QualifiedNamesConstants.NewInstanceSignature);
2074                         nameAndTypeIndex = wellKnownMethodNameAndTypes[NEWINSTANCE_METHOD_NAME_AND_TYPE] = currentIndex++;
2075                         writeU1(NameAndTypeTag);
2076                         writeU2(nameIndex);
2077                         writeU2(typeIndex);
2078                 }
2079                 index = wellKnownMethods[NEWINSTANCE_CONSTRUCTOR_METHOD] = currentIndex++;
2080                 if (index > 0xFFFF){
2081                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
2082                 }
2083                 // Write the method ref constant into the constant pool
2084                 // First add the tag
2085                 writeU1(MethodRefTag);
2086                 // Then write the class index
2087                 writeU2(classIndex);
2088                 // The write the nameAndType index
2089                 writeU2(nameAndTypeIndex);
2090         }
2091         return index;
2092 }
2093 /**
2094  * This method returns the index into the constantPool corresponding to the type descriptor.
2095  *
2096  * @param TypeBinding aTypeBinding
2097  * @return <CODE>int</CODE>
2098  */
2099 public int literalIndexForJavaLangShort() {
2100         int index;
2101         if ((index = wellKnownTypes[JAVA_LANG_SHORT_TYPE]) == 0) {
2102                 int nameIndex;
2103                 // The entry doesn't exit yet
2104                 nameIndex = literalIndex(QualifiedNamesConstants.JavaLangShortConstantPoolName);
2105                 index = wellKnownTypes[JAVA_LANG_SHORT_TYPE] = currentIndex++;
2106                 if (index > 0xFFFF){
2107                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
2108                 }
2109                 writeU1(ClassTag);
2110                 // Then add the 8 bytes representing the long
2111                 writeU2(nameIndex);
2112         }
2113         return index;
2114 }
2115 /**
2116  * This method returns the index into the constantPool
2117  * corresponding to the field binding aFieldBinding.
2118  *
2119  * @return <CODE>int</CODE>
2120  */
2121 public int literalIndexForJavaLangShortTYPE() {
2122         int index;
2123         if ((index = wellKnownFields[TYPE_SHORT_FIELD]) == 0) {
2124                 int nameAndTypeIndex;
2125                 int classIndex;
2126                 // The entry doesn't exit yet
2127                 classIndex = literalIndexForJavaLangShort();
2128                 if ((nameAndTypeIndex = wellKnownFieldNameAndTypes[TYPE_JAVALANGCLASS_NAME_AND_TYPE]) == 0) {
2129                         int nameIndex = literalIndex(QualifiedNamesConstants.TYPE);
2130                         int typeIndex = literalIndex(QualifiedNamesConstants.JavaLangClassSignature);
2131                         nameAndTypeIndex = wellKnownFieldNameAndTypes[TYPE_JAVALANGCLASS_NAME_AND_TYPE] = currentIndex++;
2132                         writeU1(NameAndTypeTag);
2133                         writeU2(nameIndex);
2134                         writeU2(typeIndex);
2135                 }
2136                 index = wellKnownFields[TYPE_SHORT_FIELD] = currentIndex++;
2137                 if (index > 0xFFFF){
2138                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
2139                 }
2140                 writeU1(FieldRefTag);
2141                 writeU2(classIndex);
2142                 writeU2(nameAndTypeIndex);
2143         }
2144         return index;
2145 }
2146 /**
2147  * This method returns the index into the constantPool corresponding to the type descriptor.
2148  *
2149  * @param TypeBinding aTypeBinding
2150  * @return <CODE>int</CODE>
2151  */
2152 public int literalIndexForJavaLangString() {
2153         int index;
2154         if ((index = wellKnownTypes[JAVA_LANG_STRING_TYPE]) == 0) {
2155                 int nameIndex;
2156                 // The entry doesn't exit yet
2157                 nameIndex = literalIndex(QualifiedNamesConstants.JavaLangStringConstantPoolName);
2158                 index = wellKnownTypes[JAVA_LANG_STRING_TYPE] = currentIndex++;
2159                 if (index > 0xFFFF){
2160                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
2161                 }
2162                 writeU1(ClassTag);
2163                 // Then add the 8 bytes representing the long
2164                 writeU2(nameIndex);
2165         }
2166         return index;
2167 }
2168 /**
2169  * This method returns the index into the constantPool corresponding to the type descriptor.
2170  *
2171  * @param TypeBinding aTypeBinding
2172  * @return <CODE>int</CODE>
2173  */
2174 public int literalIndexForJavaLangStringBuffer() {
2175         int index;
2176         if ((index = wellKnownTypes[JAVA_LANG_STRINGBUFFER_TYPE]) == 0) {
2177                 int nameIndex;
2178                 // The entry doesn't exit yet
2179                 nameIndex = literalIndex(QualifiedNamesConstants.JavaLangStringBufferConstantPoolName);
2180                 index = wellKnownTypes[JAVA_LANG_STRINGBUFFER_TYPE] = currentIndex++;
2181                 if (index > 0xFFFF){
2182                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
2183                 }
2184                 writeU1(ClassTag);
2185                 // Then add the 8 bytes representing the long
2186                 writeU2(nameIndex);
2187         }
2188         return index;
2189 }
2190 /**
2191  * This method returns the index into the constantPool corresponding to the
2192  * method descriptor. It can be either an interface method reference constant
2193  * or a method reference constant.
2194  *
2195  * @return <CODE>int</CODE>
2196  */
2197 public int literalIndexForJavaLangStringBufferAppend(int typeID) {
2198         int index = 0;
2199         int nameAndTypeIndex = 0;
2200         int classIndex = 0;
2201         switch (typeID) {
2202                 case T_int :
2203                 case T_byte :
2204                 case T_short :
2205                         if ((index = wellKnownMethods[APPEND_INT_METHOD]) == 0) {
2206                                 classIndex = literalIndexForJavaLangStringBuffer();
2207                                 if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[APPEND_INT_METHOD_NAME_AND_TYPE]) == 0) {
2208                                         int nameIndex = literalIndex(QualifiedNamesConstants.Append);
2209                                         int typeIndex = literalIndex(QualifiedNamesConstants.AppendIntSignature);
2210                                         nameAndTypeIndex = wellKnownMethodNameAndTypes[APPEND_INT_METHOD_NAME_AND_TYPE] = currentIndex++;
2211                                         writeU1(NameAndTypeTag);
2212                                         writeU2(nameIndex);
2213                                         writeU2(typeIndex);
2214                                 }
2215                                 index = wellKnownMethods[APPEND_INT_METHOD] = currentIndex++;
2216                                 if (index > 0xFFFF){
2217                                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
2218                                 }
2219                                 // Write the method ref constant into the constant pool
2220                                 // First add the tag
2221                                 writeU1(MethodRefTag);
2222                                 // Then write the class index
2223                                 writeU2(classIndex);
2224                                 // The write the nameAndType index
2225                                 writeU2(nameAndTypeIndex);
2226                         }
2227                         break;
2228                 case T_long :
2229                         if ((index = wellKnownMethods[APPEND_LONG_METHOD]) == 0) {
2230                                 classIndex = literalIndexForJavaLangStringBuffer();
2231                                 if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[APPEND_LONG_METHOD_NAME_AND_TYPE]) == 0) {
2232                                         int nameIndex = literalIndex(QualifiedNamesConstants.Append);
2233                                         int typeIndex = literalIndex(QualifiedNamesConstants.AppendLongSignature);
2234                                         nameAndTypeIndex = wellKnownMethodNameAndTypes[APPEND_LONG_METHOD_NAME_AND_TYPE] = currentIndex++;
2235                                         writeU1(NameAndTypeTag);
2236                                         writeU2(nameIndex);
2237                                         writeU2(typeIndex);
2238                                 }
2239                                 index = wellKnownMethods[APPEND_LONG_METHOD] = currentIndex++;
2240                                 if (index > 0xFFFF){
2241                                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
2242                                 }
2243                                 // Write the method ref constant into the constant pool
2244                                 // First add the tag
2245                                 writeU1(MethodRefTag);
2246                                 // Then write the class index
2247                                 writeU2(classIndex);
2248                                 // The write the nameAndType index
2249                                 writeU2(nameAndTypeIndex);
2250                         }
2251                         break;
2252                 case T_float :
2253                         if ((index = wellKnownMethods[APPEND_FLOAT_METHOD]) == 0) {
2254                                 classIndex = literalIndexForJavaLangStringBuffer();
2255                                 if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[APPEND_FLOAT_METHOD_NAME_AND_TYPE]) == 0) {
2256                                         int nameIndex = literalIndex(QualifiedNamesConstants.Append);
2257                                         int typeIndex = literalIndex(QualifiedNamesConstants.AppendFloatSignature);
2258                                         nameAndTypeIndex = wellKnownMethodNameAndTypes[APPEND_FLOAT_METHOD_NAME_AND_TYPE] = currentIndex++;
2259                                         writeU1(NameAndTypeTag);
2260                                         writeU2(nameIndex);
2261                                         writeU2(typeIndex);
2262                                 }
2263                                 index = wellKnownMethods[APPEND_FLOAT_METHOD] = currentIndex++;
2264                                 if (index > 0xFFFF){
2265                                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
2266                                 }
2267                                 // Write the method ref constant into the constant pool
2268                                 // First add the tag
2269                                 writeU1(MethodRefTag);
2270                                 // Then write the class index
2271                                 writeU2(classIndex);
2272                                 // The write the nameAndType index
2273                                 writeU2(nameAndTypeIndex);
2274                         }
2275                         break;
2276                 case T_double :
2277                         if ((index = wellKnownMethods[APPEND_DOUBLE_METHOD]) == 0) {
2278                                 classIndex = literalIndexForJavaLangStringBuffer();
2279                                 if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[APPEND_DOUBLE_METHOD_NAME_AND_TYPE]) == 0) {
2280                                         int nameIndex = literalIndex(QualifiedNamesConstants.Append);
2281                                         int typeIndex = literalIndex(QualifiedNamesConstants.AppendDoubleSignature);
2282                                         nameAndTypeIndex = wellKnownMethodNameAndTypes[APPEND_DOUBLE_METHOD_NAME_AND_TYPE] = currentIndex++;
2283                                         writeU1(NameAndTypeTag);
2284                                         writeU2(nameIndex);
2285                                         writeU2(typeIndex);
2286                                 }
2287                                 index = wellKnownMethods[APPEND_DOUBLE_METHOD] = currentIndex++;
2288                                 if (index > 0xFFFF){
2289                                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
2290                                 }
2291                                 // Write the method ref constant into the constant pool
2292                                 // First add the tag
2293                                 writeU1(MethodRefTag);
2294                                 // Then write the class index
2295                                 writeU2(classIndex);
2296                                 // The write the nameAndType index
2297                                 writeU2(nameAndTypeIndex);
2298                         }
2299                         break;
2300                 case T_char :
2301                         if ((index = wellKnownMethods[APPEND_CHAR_METHOD]) == 0) {
2302                                 classIndex = literalIndexForJavaLangStringBuffer();
2303                                 if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[APPEND_CHAR_METHOD_NAME_AND_TYPE]) == 0) {
2304                                         int nameIndex = literalIndex(QualifiedNamesConstants.Append);
2305                                         int typeIndex = literalIndex(QualifiedNamesConstants.AppendCharSignature);
2306                                         nameAndTypeIndex = wellKnownMethodNameAndTypes[APPEND_CHAR_METHOD_NAME_AND_TYPE] = currentIndex++;
2307                                         writeU1(NameAndTypeTag);
2308                                         writeU2(nameIndex);
2309                                         writeU2(typeIndex);
2310                                 }
2311                                 index = wellKnownMethods[APPEND_CHAR_METHOD] = currentIndex++;
2312                                 if (index > 0xFFFF){
2313                                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
2314                                 }
2315                                 // Write the method ref constant into the constant pool
2316                                 // First add the tag
2317                                 writeU1(MethodRefTag);
2318                                 // Then write the class index
2319                                 writeU2(classIndex);
2320                                 // The write the nameAndType index
2321                                 writeU2(nameAndTypeIndex);
2322                         }
2323                         break;
2324                 case T_boolean :
2325                         if ((index = wellKnownMethods[APPEND_BOOLEAN_METHOD]) == 0) {
2326                                 classIndex = literalIndexForJavaLangStringBuffer();
2327                                 if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[APPEND_BOOLEAN_METHOD_NAME_AND_TYPE]) == 0) {
2328                                         int nameIndex = literalIndex(QualifiedNamesConstants.Append);
2329                                         int typeIndex = literalIndex(QualifiedNamesConstants.AppendBooleanSignature);
2330                                         nameAndTypeIndex = wellKnownMethodNameAndTypes[APPEND_BOOLEAN_METHOD_NAME_AND_TYPE] = currentIndex++;
2331                                         writeU1(NameAndTypeTag);
2332                                         writeU2(nameIndex);
2333                                         writeU2(typeIndex);
2334                                 }
2335                                 index = wellKnownMethods[APPEND_BOOLEAN_METHOD] = currentIndex++;
2336                                 if (index > 0xFFFF){
2337                                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
2338                                 }
2339                                 // Write the method ref constant into the constant pool
2340                                 // First add the tag
2341                                 writeU1(MethodRefTag);
2342                                 // Then write the class index
2343                                 writeU2(classIndex);
2344                                 // The write the nameAndType index
2345                                 writeU2(nameAndTypeIndex);
2346                         }
2347                         break;
2348                 case T_Object :
2349                         if ((index = wellKnownMethods[APPEND_OBJECT_METHOD]) == 0) {
2350                                 classIndex = literalIndexForJavaLangStringBuffer();
2351                                 if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[APPEND_OBJECT_METHOD_NAME_AND_TYPE]) == 0) {
2352                                         int nameIndex = literalIndex(QualifiedNamesConstants.Append);
2353                                         int typeIndex = literalIndex(QualifiedNamesConstants.AppendObjectSignature);
2354                                         nameAndTypeIndex = wellKnownMethodNameAndTypes[APPEND_OBJECT_METHOD_NAME_AND_TYPE] = currentIndex++;
2355                                         writeU1(NameAndTypeTag);
2356                                         writeU2(nameIndex);
2357                                         writeU2(typeIndex);
2358                                 }
2359                                 index = wellKnownMethods[APPEND_OBJECT_METHOD] = currentIndex++;
2360                                 if (index > 0xFFFF){
2361                                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
2362                                 }
2363                                 // Write the method ref constant into the constant pool
2364                                 // First add the tag
2365                                 writeU1(MethodRefTag);
2366                                 // Then write the class index
2367                                 writeU2(classIndex);
2368                                 // The write the nameAndType index
2369                                 writeU2(nameAndTypeIndex);
2370                         }
2371                         break;
2372                 case T_String :
2373                 case T_null :
2374                         if ((index = wellKnownMethods[APPEND_STRING_METHOD]) == 0) {
2375                                 classIndex = literalIndexForJavaLangStringBuffer();
2376                                 if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[APPEND_STRING_METHOD_NAME_AND_TYPE]) == 0) {
2377                                         int nameIndex = literalIndex(QualifiedNamesConstants.Append);
2378                                         int typeIndex = literalIndex(QualifiedNamesConstants.AppendStringSignature);
2379                                         nameAndTypeIndex = wellKnownMethodNameAndTypes[APPEND_STRING_METHOD_NAME_AND_TYPE] = currentIndex++;
2380                                         writeU1(NameAndTypeTag);
2381                                         writeU2(nameIndex);
2382                                         writeU2(typeIndex);
2383                                 }
2384                                 index = wellKnownMethods[APPEND_STRING_METHOD] = currentIndex++;
2385                                 if (index > 0xFFFF){
2386                                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
2387                                 }
2388                                 // Write the method ref constant into the constant pool
2389                                 // First add the tag
2390                                 writeU1(MethodRefTag);
2391                                 // Then write the class index
2392                                 writeU2(classIndex);
2393                                 // The write the nameAndType index
2394                                 writeU2(nameAndTypeIndex);
2395                         }
2396                         break;
2397         }
2398         return index;
2399 }
2400 /**
2401  * This method returns the index into the constantPool corresponding to the
2402  * method descriptor. It can be either an interface method reference constant
2403  * or a method reference constant.
2404  *
2405  * @return <CODE>int</CODE>
2406  */
2407 public int literalIndexForJavaLangStringBufferConstructor() {
2408         int index;
2409         int nameAndTypeIndex;
2410         int classIndex;
2411         // Looking into the method ref table
2412         if ((index = wellKnownMethods[STRINGBUFFER_STRING_CONSTR_METHOD]) == 0) {
2413                 classIndex = literalIndexForJavaLangStringBuffer();
2414                                 if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[CONSTR_STRING_METHOD_NAME_AND_TYPE]) == 0) {
2415                                         int nameIndex = literalIndex(QualifiedNamesConstants.Init);
2416                                         int typeIndex = literalIndex(QualifiedNamesConstants.StringConstructorSignature);
2417                                         nameAndTypeIndex = wellKnownMethodNameAndTypes[CONSTR_STRING_METHOD_NAME_AND_TYPE] = currentIndex++;
2418                                         writeU1(NameAndTypeTag);
2419                                         writeU2(nameIndex);
2420                                         writeU2(typeIndex);
2421                                 }
2422                 index = wellKnownMethods[STRINGBUFFER_STRING_CONSTR_METHOD] = currentIndex++;
2423                 if (index > 0xFFFF){
2424                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
2425                 }
2426                 // Write the method ref constant into the constant pool
2427                 // First add the tag
2428                 writeU1(MethodRefTag);
2429                 // Then write the class index
2430                 writeU2(classIndex);
2431                 // The write the nameAndType index
2432                 writeU2(nameAndTypeIndex);
2433         }
2434         return index;
2435 }
2436 /**
2437  * This method returns the index into the constantPool corresponding to the
2438  * method descriptor. It can be either an interface method reference constant
2439  * or a method reference constant.
2440  *
2441  * @return <CODE>int</CODE>
2442  */
2443 public int literalIndexForJavaLangStringBufferDefaultConstructor() {
2444         int index;
2445         int nameAndTypeIndex;
2446         int classIndex;
2447         // Looking into the method ref table
2448         if ((index = wellKnownMethods[STRINGBUFFER_DEFAULT_CONSTR_METHOD]) == 0) {
2449                 classIndex = literalIndexForJavaLangStringBuffer();
2450                 if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[DEFAULT_CONSTR_METHOD_NAME_AND_TYPE]) == 0) {
2451                         int nameIndex = literalIndex(QualifiedNamesConstants.Init);
2452                         int typeIndex = literalIndex(QualifiedNamesConstants.DefaultConstructorSignature);
2453                         nameAndTypeIndex = wellKnownMethodNameAndTypes[DEFAULT_CONSTR_METHOD_NAME_AND_TYPE] = currentIndex++;
2454                         writeU1(NameAndTypeTag);
2455                         writeU2(nameIndex);
2456                         writeU2(typeIndex);
2457                 }
2458                 index = wellKnownMethods[STRINGBUFFER_DEFAULT_CONSTR_METHOD] = currentIndex++;
2459                 if (index > 0xFFFF){
2460                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
2461                 }
2462                 // Write the method ref constant into the constant pool
2463                 // First add the tag
2464                 writeU1(MethodRefTag);
2465                 // Then write the class index
2466                 writeU2(classIndex);
2467                 // The write the nameAndType index
2468                 writeU2(nameAndTypeIndex);
2469         }
2470         return index;
2471 }
2472 /**
2473  * This method returns the index into the constantPool corresponding to the
2474  * method descriptor. It can be either an interface method reference constant
2475  * or a method reference constant.
2476  *
2477  * @return <CODE>int</CODE>
2478  */
2479 public int literalIndexForJavaLangStringBufferToString() {
2480         int index;
2481         int nameAndTypeIndex;
2482         int classIndex;
2483         // Looking into the method ref table
2484         if ((index = wellKnownMethods[STRINGBUFFER_TOSTRING_METHOD]) == 0) {
2485                 classIndex = literalIndexForJavaLangStringBuffer();
2486                 if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[TOSTRING_METHOD_NAME_AND_TYPE]) == 0) {
2487                         int nameIndex = literalIndex(QualifiedNamesConstants.ToString);
2488                         int typeIndex = literalIndex(QualifiedNamesConstants.ToStringSignature);
2489                         nameAndTypeIndex = wellKnownMethodNameAndTypes[TOSTRING_METHOD_NAME_AND_TYPE] = currentIndex++;
2490                         writeU1(NameAndTypeTag);
2491                         writeU2(nameIndex);
2492                         writeU2(typeIndex);
2493                 }
2494                 index = wellKnownMethods[STRINGBUFFER_TOSTRING_METHOD] = currentIndex++;
2495                 if (index > 0xFFFF){
2496                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
2497                 }
2498                 // Write the method ref constant into the constant pool
2499                 // First add the tag
2500                 writeU1(MethodRefTag);
2501                 // Then write the class index
2502                 writeU2(classIndex);
2503                 // The write the nameAndType index
2504                 writeU2(nameAndTypeIndex);
2505         }
2506         return index;
2507 }
2508 /**
2509  * This method returns the index into the constantPool corresponding to the
2510  * method descriptor. It can be either an interface method reference constant
2511  * or a method reference constant.
2512  *
2513  * @return <CODE>int</CODE>
2514  */
2515 public int literalIndexForJavaLangStringIntern() {
2516         int index;
2517         int nameAndTypeIndex;
2518         int classIndex;
2519         // Looking into the method ref table
2520         if ((index = wellKnownMethods[STRING_INTERN_METHOD]) == 0) {
2521                 classIndex = literalIndexForJavaLangString();
2522                 if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[INTERN_METHOD_NAME_AND_TYPE]) == 0) {
2523                         int nameIndex = literalIndex(QualifiedNamesConstants.Intern);
2524                         int typeIndex = literalIndex(QualifiedNamesConstants.InternSignature);
2525                         nameAndTypeIndex = wellKnownMethodNameAndTypes[INTERN_METHOD_NAME_AND_TYPE] = currentIndex++;
2526                         writeU1(NameAndTypeTag);
2527                         writeU2(nameIndex);
2528                         writeU2(typeIndex);
2529                 }
2530                 index = wellKnownMethods[STRING_INTERN_METHOD] = currentIndex++;
2531                 if (index > 0xFFFF){
2532                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
2533                 }
2534                 // Write the method ref constant into the constant pool
2535                 // First add the tag
2536                 writeU1(MethodRefTag);
2537                 // Then write the class index
2538                 writeU2(classIndex);
2539                 // The write the nameAndType index
2540                 writeU2(nameAndTypeIndex);
2541         }
2542         return index;
2543 }
2544 /**
2545  * This method returns the index into the constantPool corresponding to the
2546  * method descriptor. It can be either an interface method reference constant
2547  * or a method reference constant.
2548  *
2549  * @return <CODE>int</CODE>
2550  */
2551 public int literalIndexForJavaLangStringValueOf(int typeID) {
2552         int index = 0;
2553         int nameAndTypeIndex = 0;
2554         int classIndex = literalIndexForJavaLangString();
2555         switch (typeID) {
2556                 case T_int :
2557                 case T_byte :
2558                 case T_short :
2559                         if ((index = wellKnownMethods[VALUEOF_INT_METHOD]) == 0) {
2560                                 if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[VALUEOF_INT_METHOD_NAME_AND_TYPE]) == 0) {
2561                                         int nameIndex = literalIndex(QualifiedNamesConstants.ValueOf);
2562                                         int typeIndex = literalIndex(QualifiedNamesConstants.ValueOfIntSignature);
2563                                         nameAndTypeIndex = wellKnownMethodNameAndTypes[VALUEOF_INT_METHOD_NAME_AND_TYPE] = currentIndex++;
2564                                         writeU1(NameAndTypeTag);
2565                                         writeU2(nameIndex);
2566                                         writeU2(typeIndex);
2567                                 }
2568                                 index = wellKnownMethods[VALUEOF_INT_METHOD] = currentIndex++;
2569                                 if (index > 0xFFFF){
2570                                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
2571                                 }
2572                                 // Write the method ref constant into the constant pool
2573                                 // First add the tag
2574                                 writeU1(MethodRefTag);
2575                                 // Then write the class index
2576                                 writeU2(classIndex);
2577                                 // The write the nameAndType index
2578                                 writeU2(nameAndTypeIndex);
2579                         }
2580                         break;
2581                 case T_long :
2582                         if ((index = wellKnownMethods[VALUEOF_LONG_METHOD]) == 0) {
2583                                 if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[VALUEOF_LONG_METHOD_NAME_AND_TYPE]) == 0) {
2584                                         int nameIndex = literalIndex(QualifiedNamesConstants.ValueOf);
2585                                         int typeIndex = literalIndex(QualifiedNamesConstants.ValueOfLongSignature);
2586                                         nameAndTypeIndex = wellKnownMethodNameAndTypes[VALUEOF_LONG_METHOD_NAME_AND_TYPE] = currentIndex++;
2587                                         writeU1(NameAndTypeTag);
2588                                         writeU2(nameIndex);
2589                                         writeU2(typeIndex);
2590                                 }
2591                                 index = wellKnownMethods[VALUEOF_LONG_METHOD] = currentIndex++;
2592                                 if (index > 0xFFFF){
2593                                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
2594                                 }
2595                                 // Write the method ref constant into the constant pool
2596                                 // First add the tag
2597                                 writeU1(MethodRefTag);
2598                                 // Then write the class index
2599                                 writeU2(classIndex);
2600                                 // The write the nameAndType index
2601                                 writeU2(nameAndTypeIndex);
2602                         }
2603                         break;
2604                 case T_float :
2605                         if ((index = wellKnownMethods[VALUEOF_FLOAT_METHOD]) == 0) {
2606                                 if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[VALUEOF_FLOAT_METHOD_NAME_AND_TYPE]) == 0) {
2607                                         int nameIndex = literalIndex(QualifiedNamesConstants.ValueOf);
2608                                         int typeIndex = literalIndex(QualifiedNamesConstants.ValueOfFloatSignature);
2609                                         nameAndTypeIndex = wellKnownMethodNameAndTypes[VALUEOF_FLOAT_METHOD_NAME_AND_TYPE] = currentIndex++;
2610                                         writeU1(NameAndTypeTag);
2611                                         writeU2(nameIndex);
2612                                         writeU2(typeIndex);
2613                                 }
2614                                 index = wellKnownMethods[VALUEOF_FLOAT_METHOD] = currentIndex++;
2615                                 if (index > 0xFFFF){
2616                                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
2617                                 }
2618                                 // Write the method ref constant into the constant pool
2619                                 // First add the tag
2620                                 writeU1(MethodRefTag);
2621                                 // Then write the class index
2622                                 writeU2(classIndex);
2623                                 // The write the nameAndType index
2624                                 writeU2(nameAndTypeIndex);
2625                         }
2626                         break;
2627                 case T_double :
2628                         if ((index = wellKnownMethods[VALUEOF_DOUBLE_METHOD]) == 0) {
2629                                 if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[VALUEOF_DOUBLE_METHOD_NAME_AND_TYPE]) == 0) {
2630                                         int nameIndex = literalIndex(QualifiedNamesConstants.ValueOf);
2631                                         int typeIndex = literalIndex(QualifiedNamesConstants.ValueOfDoubleSignature);
2632                                         nameAndTypeIndex = wellKnownMethodNameAndTypes[VALUEOF_DOUBLE_METHOD_NAME_AND_TYPE] = currentIndex++;
2633                                         writeU1(NameAndTypeTag);
2634                                         writeU2(nameIndex);
2635                                         writeU2(typeIndex);
2636                                 }
2637                                 index = wellKnownMethods[VALUEOF_DOUBLE_METHOD] = currentIndex++;
2638                                 if (index > 0xFFFF){
2639                                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
2640                                 }
2641                                 // Write the method ref constant into the constant pool
2642                                 // First add the tag
2643                                 writeU1(MethodRefTag);
2644                                 // Then write the class index
2645                                 writeU2(classIndex);
2646                                 // The write the nameAndType index
2647                                 writeU2(nameAndTypeIndex);
2648                         }
2649                         break;
2650                 case T_char :
2651                         if ((index = wellKnownMethods[VALUEOF_CHAR_METHOD]) == 0) {
2652                                 if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[VALUEOF_CHAR_METHOD_NAME_AND_TYPE]) == 0) {
2653                                         int nameIndex = literalIndex(QualifiedNamesConstants.ValueOf);
2654                                         int typeIndex = literalIndex(QualifiedNamesConstants.ValueOfCharSignature);
2655                                         nameAndTypeIndex = wellKnownMethodNameAndTypes[VALUEOF_CHAR_METHOD_NAME_AND_TYPE] = currentIndex++;
2656                                         writeU1(NameAndTypeTag);
2657                                         writeU2(nameIndex);
2658                                         writeU2(typeIndex);
2659                                 }
2660                                 index = wellKnownMethods[VALUEOF_CHAR_METHOD] = currentIndex++;
2661                                 if (index > 0xFFFF){
2662                                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
2663                                 }
2664                                 // Write the method ref constant into the constant pool
2665                                 // First add the tag
2666                                 writeU1(MethodRefTag);
2667                                 // Then write the class index
2668                                 writeU2(classIndex);
2669                                 // The write the nameAndType index
2670                                 writeU2(nameAndTypeIndex);
2671                         }
2672                         break;
2673                 case T_boolean :
2674                         if ((index = wellKnownMethods[VALUEOF_BOOLEAN_METHOD]) == 0) {
2675                                 if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[VALUEOF_BOOLEAN_METHOD_NAME_AND_TYPE]) == 0) {
2676                                         int nameIndex = literalIndex(QualifiedNamesConstants.ValueOf);
2677                                         int typeIndex = literalIndex(QualifiedNamesConstants.ValueOfBooleanSignature);
2678                                         nameAndTypeIndex = wellKnownMethodNameAndTypes[VALUEOF_BOOLEAN_METHOD_NAME_AND_TYPE] = currentIndex++;
2679                                         writeU1(NameAndTypeTag);
2680                                         writeU2(nameIndex);
2681                                         writeU2(typeIndex);
2682                                 }
2683                                 index = wellKnownMethods[VALUEOF_BOOLEAN_METHOD] = currentIndex++;
2684                                 if (index > 0xFFFF){
2685                                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
2686                                 }
2687                                 // Write the method ref constant into the constant pool
2688                                 // First add the tag
2689                                 writeU1(MethodRefTag);
2690                                 // Then write the class index
2691                                 writeU2(classIndex);
2692                                 // The write the nameAndType index
2693                                 writeU2(nameAndTypeIndex);
2694                         }
2695                         break;
2696                 case T_Object :
2697                         if ((index = wellKnownMethods[VALUEOF_OBJECT_METHOD]) == 0) {
2698                                 if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[VALUEOF_OBJECT_METHOD_NAME_AND_TYPE]) == 0) {
2699                                         int nameIndex = literalIndex(QualifiedNamesConstants.ValueOf);
2700                                         int typeIndex = literalIndex(QualifiedNamesConstants.ValueOfObjectSignature);
2701                                         nameAndTypeIndex = wellKnownMethodNameAndTypes[VALUEOF_OBJECT_METHOD_NAME_AND_TYPE] = currentIndex++;
2702                                         writeU1(NameAndTypeTag);
2703                                         writeU2(nameIndex);
2704                                         writeU2(typeIndex);
2705                                 }
2706                                 index = wellKnownMethods[VALUEOF_OBJECT_METHOD] = currentIndex++;
2707                                 if (index > 0xFFFF){
2708                                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
2709                                 }
2710                                 // Write the method ref constant into the constant pool
2711                                 // First add the tag
2712                                 writeU1(MethodRefTag);
2713                                 // Then write the class index
2714                                 writeU2(classIndex);
2715                                 // The write the nameAndType index
2716                                 writeU2(nameAndTypeIndex);
2717                         }
2718                         break;
2719         }
2720         return index;
2721 }
2722 /**
2723  * This method returns the index into the constantPool corresponding to the type descriptor.
2724  *
2725  * @param TypeBinding aTypeBinding
2726  * @return <CODE>int</CODE>
2727  */
2728 public int literalIndexForJavaLangSystem() {
2729         int index;
2730         if ((index = wellKnownTypes[JAVA_LANG_SYSTEM_TYPE]) == 0) {
2731                 int nameIndex;
2732                 // The entry doesn't exit yet
2733                 nameIndex = literalIndex(QualifiedNamesConstants.JavaLangSystemConstantPoolName);
2734                 index = wellKnownTypes[JAVA_LANG_SYSTEM_TYPE] = currentIndex++;
2735                 if (index > 0xFFFF){
2736                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
2737                 }
2738                 writeU1(ClassTag);
2739                 // Then add the 8 bytes representing the long
2740                 writeU2(nameIndex);
2741         }
2742         return index;
2743 }
2744 /**
2745  * This method returns the index into the constantPool corresponding to the
2746  * method descriptor. It can be either an interface method reference constant
2747  * or a method reference constant.
2748  *
2749  * @return <CODE>int</CODE>
2750  */
2751 public int literalIndexForJavaLangSystemExitInt() {
2752         int index;
2753         int nameAndTypeIndex;
2754         int classIndex;
2755         // Looking into the method ref table
2756         if ((index = wellKnownMethods[SYSTEM_EXIT_METHOD]) == 0) {
2757                 classIndex = literalIndexForJavaLangSystem();
2758                 if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[EXIT_METHOD_NAME_AND_TYPE]) == 0) {
2759                         int nameIndex = literalIndex(QualifiedNamesConstants.Exit);
2760                         int typeIndex = literalIndex(QualifiedNamesConstants.ExitIntSignature);
2761                         nameAndTypeIndex = wellKnownMethodNameAndTypes[EXIT_METHOD_NAME_AND_TYPE] = currentIndex++;
2762                         writeU1(NameAndTypeTag);
2763                         writeU2(nameIndex);
2764                         writeU2(typeIndex);
2765                 }
2766                 index = wellKnownMethods[SYSTEM_EXIT_METHOD] = currentIndex++;
2767                 if (index > 0xFFFF){
2768                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
2769                 }
2770                 // Write the method ref constant into the constant pool
2771                 // First add the tag
2772                 writeU1(MethodRefTag);
2773                 // Then write the class index
2774                 writeU2(classIndex);
2775                 // The write the nameAndType index
2776                 writeU2(nameAndTypeIndex);
2777         }
2778         return index;
2779 }
2780 /**
2781  * This method returns the index into the constantPool
2782  * corresponding to the field binding aFieldBinding.
2783  *
2784  * @return <CODE>int</CODE>
2785  */
2786 public int literalIndexForJavaLangSystemOut() {
2787         int index;
2788         if ((index = wellKnownFields[OUT_SYSTEM_FIELD]) == 0) {
2789                 int nameAndTypeIndex;
2790                 int classIndex;
2791                 // The entry doesn't exit yet
2792                 classIndex = literalIndexForJavaLangSystem();
2793                 if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[OUT_SYSTEM_NAME_AND_TYPE]) == 0) {
2794                         int nameIndex = literalIndex(QualifiedNamesConstants.Out);
2795                         int typeIndex = literalIndex(QualifiedNamesConstants.JavaIoPrintStreamSignature);
2796                         nameAndTypeIndex = wellKnownMethodNameAndTypes[OUT_SYSTEM_NAME_AND_TYPE] = currentIndex++;
2797                         writeU1(NameAndTypeTag);
2798                         writeU2(nameIndex);
2799                         writeU2(typeIndex);
2800                 }
2801                 index = wellKnownFields[OUT_SYSTEM_FIELD] = currentIndex++;
2802                 if (index > 0xFFFF){
2803                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
2804                 }
2805                 writeU1(FieldRefTag);
2806                 writeU2(classIndex);
2807                 writeU2(nameAndTypeIndex);
2808         }
2809         return index;
2810 }
2811 /**
2812  * This method returns the index into the constantPool corresponding to the type descriptor.
2813  *
2814  * @param TypeBinding aTypeBinding
2815  * @return <CODE>int</CODE>
2816  */
2817 public int literalIndexForJavaLangThrowable() {
2818         int index;
2819         if ((index = wellKnownTypes[JAVA_LANG_THROWABLE_TYPE]) == 0) {
2820                 int nameIndex;
2821                 // The entry doesn't exit yet
2822                 nameIndex = literalIndex(QualifiedNamesConstants.JavaLangThrowableConstantPoolName);
2823                 index = wellKnownTypes[JAVA_LANG_THROWABLE_TYPE] = currentIndex++;
2824                 if (index > 0xFFFF){
2825                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
2826                 }
2827                 writeU1(ClassTag);
2828                 // Then add the 8 bytes representing the long
2829                 writeU2(nameIndex);
2830         }
2831         return index;
2832 }
2833 /**
2834  * This method returns the index into the constantPool corresponding to the
2835  * method descriptor. It can be either an interface method reference constant
2836  * or a method reference constant.
2837  *
2838  * @return <CODE>int</CODE>
2839  */
2840 public int literalIndexForJavaLangThrowableGetMessage() {
2841         int index;
2842         int nameAndTypeIndex;
2843         int classIndex;
2844         // Looking into the method ref table
2845         if ((index = wellKnownMethods[THROWABLE_GETMESSAGE_METHOD]) == 0) {
2846                 classIndex = literalIndexForJavaLangThrowable();
2847                 if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[GETMESSAGE_METHOD_NAME_AND_TYPE]) == 0) {
2848                         int nameIndex = literalIndex(QualifiedNamesConstants.GetMessage);
2849                         int typeIndex = literalIndex(QualifiedNamesConstants.GetMessageSignature);
2850                         nameAndTypeIndex = wellKnownMethodNameAndTypes[GETMESSAGE_METHOD_NAME_AND_TYPE] = currentIndex++;
2851                         writeU1(NameAndTypeTag);
2852                         writeU2(nameIndex);
2853                         writeU2(typeIndex);
2854                 }
2855                 index = wellKnownMethods[THROWABLE_GETMESSAGE_METHOD] = currentIndex++;
2856                 if (index > 0xFFFF){
2857                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
2858                 }
2859                 // Write the method ref constant into the constant pool
2860                 // First add the tag
2861                 writeU1(MethodRefTag);
2862                 // Then write the class index
2863                 writeU2(classIndex);
2864                 // The write the nameAndType index
2865                 writeU2(nameAndTypeIndex);
2866         }
2867         return index;
2868 }
2869 /**
2870  * This method returns the index into the constantPool corresponding to the type descriptor.
2871  *
2872  * @param TypeBinding aTypeBinding
2873  * @return <CODE>int</CODE>
2874  */
2875 public int literalIndexForJavaLangVoid() {
2876         int index;
2877         if ((index = wellKnownTypes[JAVA_LANG_VOID_TYPE]) == 0) {
2878                 int nameIndex;
2879                 // The entry doesn't exit yet
2880                 nameIndex = literalIndex(QualifiedNamesConstants.JavaLangVoidConstantPoolName);
2881                 index = wellKnownTypes[JAVA_LANG_VOID_TYPE] = currentIndex++;
2882                 if (index > 0xFFFF){
2883                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
2884                 }
2885                 writeU1(ClassTag);
2886                 // Then add the 8 bytes representing the long
2887                 writeU2(nameIndex);
2888         }
2889         return index;
2890 }
2891 /**
2892  * This method returns the index into the constantPool
2893  * corresponding to the field binding aFieldBinding.
2894  *
2895  * @return <CODE>int</CODE>
2896  */
2897 public int literalIndexForJavaLangVoidTYPE() {
2898         int index;
2899         if ((index = wellKnownFields[TYPE_VOID_FIELD]) == 0) {
2900                 int nameAndTypeIndex;
2901                 int classIndex;
2902                 // The entry doesn't exit yet
2903                 classIndex = literalIndexForJavaLangVoid();
2904                 if ((nameAndTypeIndex = wellKnownFieldNameAndTypes[TYPE_JAVALANGCLASS_NAME_AND_TYPE]) == 0) {
2905                         int nameIndex = literalIndex(QualifiedNamesConstants.TYPE);
2906                         int typeIndex = literalIndex(QualifiedNamesConstants.JavaLangClassSignature);
2907                         nameAndTypeIndex = wellKnownFieldNameAndTypes[TYPE_JAVALANGCLASS_NAME_AND_TYPE] = currentIndex++;
2908                         writeU1(NameAndTypeTag);
2909                         writeU2(nameIndex);
2910                         writeU2(typeIndex);
2911                 }
2912                 index = wellKnownFields[TYPE_VOID_FIELD] = currentIndex++;
2913                 if (index > 0xFFFF){
2914                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
2915                 }
2916                 writeU1(FieldRefTag);
2917                 writeU2(classIndex);
2918                 writeU2(nameAndTypeIndex);
2919         }
2920         return index;
2921 }
2922 /**
2923  * This method returns the index into the constantPool corresponding to the type descriptor.
2924  *
2925  * @param char[] stringName
2926  * @return <CODE>int</CODE>
2927  */
2928 public int literalIndexForLdc(char[] stringCharArray) {
2929         int index;
2930         if ((index = stringCache.get(stringCharArray)) < 0) {
2931                 int stringIndex;
2932                 // The entry doesn't exit yet
2933                 if ((stringIndex = UTF8Cache.get(stringCharArray)) < 0) {
2934                         // The entry doesn't exit yet
2935                         // Write the tag first
2936                         writeU1(Utf8Tag);
2937                         // Then the size of the stringName array
2938                         int savedCurrentOffset = currentOffset;
2939                         if (currentOffset + 2 >= poolContent.length) {
2940                                 // we need to resize the poolContent array because we won't have
2941                                 // enough space to write the length
2942                                 int length = poolContent.length;
2943                                 System.arraycopy(poolContent, 0, (poolContent = new byte[length + CONSTANTPOOL_GROW_SIZE]), 0, length);
2944                         }
2945                         currentOffset += 2;
2946                         int length = 0;
2947                         for (int i = 0; i < stringCharArray.length; i++) {
2948                                 char current = stringCharArray[i];
2949                                 if ((current >= 0x0001) && (current <= 0x007F)) {
2950                                         // we only need one byte: ASCII table
2951                                         writeU1(current);
2952                                         length++;
2953                                 } else
2954                                         if (current > 0x07FF) {
2955                                                 // we need 3 bytes
2956                                                 length += 3;
2957                                                 writeU1(0xE0 | ((current >> 12) & 0x0F)); // 0xE0 = 1110 0000
2958                                                 writeU1(0x80 | ((current >> 6) & 0x3F)); // 0x80 = 1000 0000
2959                                                 writeU1(0x80 | (current & 0x3F)); // 0x80 = 1000 0000
2960                                         } else {
2961                                                 // we can be 0 or between 0x0080 and 0x07FF
2962                                                 // In that case we only need 2 bytes
2963                                                 length += 2;
2964                                                 writeU1(0xC0 | ((current >> 6) & 0x1F)); // 0xC0 = 1100 0000
2965                                                 writeU1(0x80 | (current & 0x3F)); // 0x80 = 1000 0000
2966                                         }
2967                         }
2968                         if (length >= 65535) {
2969                                 currentOffset = savedCurrentOffset - 1;
2970                                 return -1;
2971                         }
2972                         stringIndex = UTF8Cache.put(stringCharArray, currentIndex++);
2973                         // Now we know the length that we have to write in the constant pool
2974                         // we use savedCurrentOffset to do that
2975                         if (length > 65535) {
2976                                 return 0;
2977                         }
2978                         poolContent[savedCurrentOffset] = (byte) (length >> 8);
2979                         poolContent[savedCurrentOffset + 1] = (byte) length;
2980                 }
2981                 index = stringCache.put(stringCharArray, currentIndex++);
2982                 if (index > 0xFFFF){
2983                         this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
2984                 }
2985                 // Write the tag first
2986                 writeU1(StringTag);
2987                 // Then the string index
2988                 writeU2(stringIndex);
2989         }
2990         return index;
2991 }
2992 /**
2993  * This method returns the index into the constantPool corresponding
2994  * nameAndType constant with nameIndex, typeIndex.
2995  *
2996  * @param int nameIndex
2997  * @param int nameIndex
2998  * @param org.eclipse.jdt.internal.compiler.lookup.MethodBinding a methodBinding
2999  * @return <CODE>int</CODE>
3000  */
3001 public int literalIndexForMethods(int nameIndex, int typeIndex, MethodBinding key) {
3002         int index;
3003         int indexOfWellKnownMethodNameAndType;
3004         if ((indexOfWellKnownMethodNameAndType = indexOfWellKnownMethodNameAndType(key)) == -1) {
3005                 // check if the entry exists
3006                 if ((index = nameAndTypeCacheForMethods.get(key)) == -1) {
3007                         // The entry doesn't exit yet
3008                         index = nameAndTypeCacheForMethods.put(key, currentIndex++);
3009                         if (index > 0xFFFF){
3010                                 this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
3011                         }
3012                         writeU1(NameAndTypeTag);
3013                         writeU2(nameIndex);
3014                         writeU2(typeIndex);
3015                 }
3016         } else {
3017                 if ((index = wellKnownMethodNameAndTypes[indexOfWellKnownMethodNameAndType]) == 0) {
3018                         index = wellKnownMethodNameAndTypes[indexOfWellKnownMethodNameAndType] = currentIndex++;
3019                         if (index > 0xFFFF){
3020                                 this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
3021                         }
3022                         writeU1(NameAndTypeTag);
3023                         writeU2(nameIndex);
3024                         writeU2(typeIndex);
3025                 }
3026         }
3027         return index;
3028 }
3029 /**
3030  * This method returns the index into the constantPool corresponding to the
3031  * method descriptor. It can be either an interface method reference constant
3032  * or a method reference constant.
3033  *
3034  * @return <CODE>int</CODE>
3035  */
3036 public int literalIndexForJavaLangObjectGetClass() {
3037         int index;
3038         int nameAndTypeIndex;
3039         int classIndex;
3040         // Looking into the method ref table
3041         if ((index = wellKnownMethods[GETCLASS_OBJECT_METHOD]) == 0) {
3042                 classIndex = literalIndexForJavaLangObject();
3043                 if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[GETCLASS_OBJECT_METHOD_NAME_AND_TYPE]) == 0) {
3044                         int nameIndex = literalIndex(QualifiedNamesConstants.GetClass);
3045                         int typeIndex = literalIndex(QualifiedNamesConstants.GetClassSignature);
3046                         nameAndTypeIndex = wellKnownMethodNameAndTypes[GETCLASS_OBJECT_METHOD_NAME_AND_TYPE] = currentIndex++;
3047                         writeU1(NameAndTypeTag);
3048                         writeU2(nameIndex);
3049                         writeU2(typeIndex);
3050                 }
3051                 index = wellKnownMethods[GETCLASS_OBJECT_METHOD] = currentIndex++;
3052                 // Write the method ref constant into the constant pool
3053                 // First add the tag
3054                 writeU1(MethodRefTag);
3055                 // Then write the class index
3056                 writeU2(classIndex);
3057                 // The write the nameAndType index
3058                 writeU2(nameAndTypeIndex);
3059         }
3060         return index;
3061 }
3062 /**
3063  * This method is used to clean the receiver in case of a clinit header is generated, but the
3064  * clinit has no code.
3065  * This implementation assumes that the clinit is the first method to be generated.
3066  * @see org.eclipse.jdt.internal.compiler.ast.TypeDeclaration#addClinit()
3067  */
3068 public void resetForClinit(int constantPoolIndex, int constantPoolOffset) {
3069         currentIndex = constantPoolIndex;
3070         currentOffset = constantPoolOffset;
3071         if (UTF8Cache.get(AttributeNamesConstants.CodeName) >= constantPoolIndex) {
3072                 UTF8Cache.remove(AttributeNamesConstants.CodeName);
3073         }
3074         if (UTF8Cache.get(QualifiedNamesConstants.ClinitSignature) >= constantPoolIndex) {
3075                 UTF8Cache.remove(QualifiedNamesConstants.ClinitSignature);
3076         }
3077         if (UTF8Cache.get(QualifiedNamesConstants.Clinit) >= constantPoolIndex) {
3078                 UTF8Cache.remove(QualifiedNamesConstants.Clinit);
3079         }
3080 }
3081 /**
3082  * Write a unsigned byte into the byte array
3083  *
3084  * @param <CODE>int</CODE> The value to write into the byte array
3085  */
3086 protected final void writeU1(int value) {
3087         try {
3088                 poolContent[currentOffset++] = (byte) value;
3089         } catch (IndexOutOfBoundsException e) {
3090                 //currentOffset has been ++ already (see the -1)
3091                 int length = poolContent.length;
3092                 System.arraycopy(poolContent, 0, (poolContent = new byte[length + CONSTANTPOOL_GROW_SIZE]), 0, length);
3093                 poolContent[currentOffset - 1] = (byte) value;
3094         }
3095 }
3096 /**
3097  * Write a unsigned byte into the byte array
3098  *
3099  * @param <CODE>int</CODE> The value to write into the byte array
3100  */
3101 protected final void writeU2(int value) {
3102         //first byte
3103         try {
3104                 poolContent[currentOffset++] = (byte) (value >> 8);
3105         } catch (IndexOutOfBoundsException e) {
3106                  //currentOffset has been ++ already (see the -1)
3107                 int length = poolContent.length;
3108                 System.arraycopy(poolContent, 0, (poolContent = new byte[length + CONSTANTPOOL_GROW_SIZE]), 0, length);
3109                 poolContent[currentOffset - 1] = (byte) (value >> 8);
3110         }
3111         try {
3112                 poolContent[currentOffset++] = (byte) value;
3113         } catch (IndexOutOfBoundsException e) {
3114                  //currentOffset has been ++ already (see the -1)
3115                 int length = poolContent.length;
3116                 System.arraycopy(poolContent, 0, (poolContent = new byte[length + CONSTANTPOOL_GROW_SIZE]), 0, length);
3117                 poolContent[currentOffset - 1] = (byte) value;
3118         }
3119 }
3120 }