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