package org.eclipse.jdt.internal.eval;

/*
 * (c) Copyright IBM Corp. 2000, 2001.
 * All Rights Reserved.
 */
import org.eclipse.jdt.internal.compiler.codegen.*;
import org.eclipse.jdt.internal.compiler.lookup.*;
import org.eclipse.jdt.internal.compiler.util.*;

/**
 * This constant pool is used to manage well known methods and fields related specifically to the
 * code snippet code generation (java.lang.reflect classes).
 */
public class CodeSnippetConstantPool extends ConstantPool implements TypeConstants {

	// predefined type constant names
	final static char[][] JAVA_LANG_REFLECT_FIELD = new char[][] {JAVA, LANG, REFLECT, "Field"/*nonNLS*/.toCharArray()};
	final static char[][] JAVA_LANG_REFLECT_ACCESSIBLEOBJECT = new char[][] {JAVA, LANG, REFLECT, "AccessibleObject"/*nonNLS*/.toCharArray()};
	final static char[][] JAVA_LANG_REFLECT_METHOD = new char[][] {JAVA, LANG, REFLECT, "Method"/*nonNLS*/.toCharArray()};
	final static char[][] JAVA_LANG_REFLECT_ARRAY = new char[][] {JAVA, LANG, REFLECT, "Array"/*nonNLS*/.toCharArray()};

	// predefined methods constant names
	final static char[] GETDECLAREDFIELD_NAME = "getDeclaredField"/*nonNLS*/.toCharArray();
	final static char[] GETDECLAREDFIELD_SIGNATURE = "(Ljava/lang/String;)Ljava/lang/reflect/Field;"/*nonNLS*/.toCharArray();
	final static char[] SETACCESSIBLE_NAME = "setAccessible"/*nonNLS*/.toCharArray();
	final static char[] SETACCESSIBLE_SIGNATURE = "(Z)V"/*nonNLS*/.toCharArray();
	final static char[] JAVALANGREFLECTFIELD_CONSTANTPOOLNAME = "java/lang/reflect/Field"/*nonNLS*/.toCharArray();
	final static char[] JAVALANGREFLECTACCESSIBLEOBJECT_CONSTANTPOOLNAME = "java/lang/reflect/AccessibleObject"/*nonNLS*/.toCharArray();
	final static char[] JAVALANGREFLECTARRAY_CONSTANTPOOLNAME = "java/lang/reflect/Array"/*nonNLS*/.toCharArray();
	final static char[] JAVALANGREFLECTMETHOD_CONSTANTPOOLNAME = "java/lang/reflect/Method"/*nonNLS*/.toCharArray();
	final static char[] GET_INT_METHOD_NAME = "getInt"/*nonNLS*/.toCharArray();
	final static char[] GET_LONG_METHOD_NAME = "getLong"/*nonNLS*/.toCharArray();
	final static char[] GET_DOUBLE_METHOD_NAME = "getDouble"/*nonNLS*/.toCharArray();
	final static char[] GET_FLOAT_METHOD_NAME = "getFloat"/*nonNLS*/.toCharArray();
	final static char[] GET_BYTE_METHOD_NAME = "getByte"/*nonNLS*/.toCharArray();
	final static char[] GET_CHAR_METHOD_NAME = "getChar"/*nonNLS*/.toCharArray();
	final static char[] GET_BOOLEAN_METHOD_NAME = "getBoolean"/*nonNLS*/.toCharArray();
	final static char[] GET_OBJECT_METHOD_NAME = "get"/*nonNLS*/.toCharArray();
	final static char[] GET_SHORT_METHOD_NAME = "getShort"/*nonNLS*/.toCharArray();
	final static char[] ARRAY_NEWINSTANCE_NAME = "newInstance"/*nonNLS*/.toCharArray();
	final static char[] GET_INT_METHOD_SIGNATURE = "(Ljava/lang/Object;)I"/*nonNLS*/.toCharArray();
	final static char[] GET_LONG_METHOD_SIGNATURE = "(Ljava/lang/Object;)J"/*nonNLS*/.toCharArray();
	final static char[] GET_DOUBLE_METHOD_SIGNATURE = "(Ljava/lang/Object;)D"/*nonNLS*/.toCharArray();
	final static char[] GET_FLOAT_METHOD_SIGNATURE = "(Ljava/lang/Object;)F"/*nonNLS*/.toCharArray();
	final static char[] GET_BYTE_METHOD_SIGNATURE = "(Ljava/lang/Object;)B"/*nonNLS*/.toCharArray();
	final static char[] GET_CHAR_METHOD_SIGNATURE = "(Ljava/lang/Object;)C"/*nonNLS*/.toCharArray();
	final static char[] GET_BOOLEAN_METHOD_SIGNATURE = "(Ljava/lang/Object;)Z"/*nonNLS*/.toCharArray();
	final static char[] GET_OBJECT_METHOD_SIGNATURE = "(Ljava/lang/Object;)Ljava/lang/Object;"/*nonNLS*/.toCharArray();
	final static char[] GET_SHORT_METHOD_SIGNATURE = "(Ljava/lang/Object;)S"/*nonNLS*/.toCharArray();
	final static char[] SET_INT_METHOD_NAME = "setInt"/*nonNLS*/.toCharArray();
	final static char[] SET_LONG_METHOD_NAME = "setLong"/*nonNLS*/.toCharArray();
	final static char[] SET_DOUBLE_METHOD_NAME = "setDouble"/*nonNLS*/.toCharArray();
	final static char[] SET_FLOAT_METHOD_NAME = "setFloat"/*nonNLS*/.toCharArray();
	final static char[] SET_BYTE_METHOD_NAME = "setByte"/*nonNLS*/.toCharArray();
	final static char[] SET_CHAR_METHOD_NAME = "setChar"/*nonNLS*/.toCharArray();
	final static char[] SET_BOOLEAN_METHOD_NAME = "setBoolean"/*nonNLS*/.toCharArray();
	final static char[] SET_OBJECT_METHOD_NAME = "set"/*nonNLS*/.toCharArray();
	final static char[] SET_SHORT_METHOD_NAME = "setShort"/*nonNLS*/.toCharArray();
	final static char[] GETCLASS_OBJECT_METHOD_NAME = "getClass"/*nonNLS*/.toCharArray();
	final static char[] SET_INT_METHOD_SIGNATURE = "(Ljava/lang/Object;I)V"/*nonNLS*/.toCharArray();
	final static char[] SET_LONG_METHOD_SIGNATURE = "(Ljava/lang/Object;J)V"/*nonNLS*/.toCharArray();
	final static char[] SET_DOUBLE_METHOD_SIGNATURE = "(Ljava/lang/Object;D)V"/*nonNLS*/.toCharArray();
	final static char[] SET_FLOAT_METHOD_SIGNATURE = "(Ljava/lang/Object;F)V"/*nonNLS*/.toCharArray();
	final static char[] SET_BYTE_METHOD_SIGNATURE = "(Ljava/lang/Object;B)V"/*nonNLS*/.toCharArray();
	final static char[] SET_CHAR_METHOD_SIGNATURE = "(Ljava/lang/Object;C)V"/*nonNLS*/.toCharArray();
	final static char[] SET_BOOLEAN_METHOD_SIGNATURE = "(Ljava/lang/Object;Z)V"/*nonNLS*/.toCharArray();
	final static char[] SET_OBJECT_METHOD_SIGNATURE = "(Ljava/lang/Object;Ljava/lang/Object;)V"/*nonNLS*/.toCharArray();
	final static char[] SET_SHORT_METHOD_SIGNATURE = "(Ljava/lang/Object;S)V"/*nonNLS*/.toCharArray();
	final static char[] GETDECLAREDMETHOD_NAME = "getDeclaredMethod"/*nonNLS*/.toCharArray();
	final static char[] GETDECLAREDMETHOD_SIGNATURE = "(Ljava/lang/String;[Ljava/lang/Class;)Ljava/lang/reflect/Method;"/*nonNLS*/.toCharArray();
	final static char[] ARRAY_NEWINSTANCE_SIGNATURE = "(Ljava/lang/Class;[I)Ljava/lang/Object;"/*nonNLS*/.toCharArray();
	final static char[] GETCLASS_OBJECT_METHOD_SIGNATURE = "()Ljava/lang/Class;"/*nonNLS*/.toCharArray();
	final static char[] INVOKE_METHOD_METHOD_NAME = "invoke"/*nonNLS*/.toCharArray();
	final static char[] INVOKE_METHOD_METHOD_SIGNATURE = "(Ljava/lang/Object;[Ljava/lang/Object;)Ljava/lang/Object;"/*nonNLS*/.toCharArray();
	final static char[] BYTEVALUE_BYTE_METHOD_NAME = "byteValue"/*nonNLS*/.toCharArray();
	final static char[] BYTEVALUE_BYTE_METHOD_SIGNATURE = "()B"/*nonNLS*/.toCharArray();
	final static char[] SHORTVALUE_SHORT_METHOD_NAME = "shortValue"/*nonNLS*/.toCharArray();
	final static char[] DOUBLEVALUE_DOUBLE_METHOD_NAME = "doubleValue"/*nonNLS*/.toCharArray();
	final static char[] FLOATVALUE_FLOAT_METHOD_NAME = "floatValue"/*nonNLS*/.toCharArray();
	final static char[] INTVALUE_INTEGER_METHOD_NAME = "intValue"/*nonNLS*/.toCharArray();
	final static char[] CHARVALUE_CHARACTER_METHOD_NAME = "charValue"/*nonNLS*/.toCharArray();
	final static char[] BOOLEANVALUE_BOOLEAN_METHOD_NAME = "booleanValue"/*nonNLS*/.toCharArray();
	final static char[] LONGVALUE_LONG_METHOD_NAME = "longValue"/*nonNLS*/.toCharArray();
	final static char[] SHORTVALUE_SHORT_METHOD_SIGNATURE = "()S"/*nonNLS*/.toCharArray();
	final static char[] DOUBLEVALUE_DOUBLE_METHOD_SIGNATURE = "()D"/*nonNLS*/.toCharArray();
	final static char[] FLOATVALUE_FLOAT_METHOD_SIGNATURE = "()F"/*nonNLS*/.toCharArray();
	final static char[] INTVALUE_INTEGER_METHOD_SIGNATURE = "()I"/*nonNLS*/.toCharArray();
	final static char[] CHARVALUE_CHARACTER_METHOD_SIGNATURE = "()C"/*nonNLS*/.toCharArray();
	final static char[] BOOLEANVALUE_BOOLEAN_METHOD_SIGNATURE = "()Z"/*nonNLS*/.toCharArray();
	final static char[] LONGVALUE_LONG_METHOD_SIGNATURE = "()J"/*nonNLS*/.toCharArray();
	final static char[] GETDECLAREDCONSTRUCTOR_NAME = "getDeclaredConstructor"/*nonNLS*/.toCharArray();
	final static char[] GETDECLAREDCONSTRUCTOR_SIGNATURE = "([Ljava/lang/Class;)Ljava/lang/reflect/Constructor;"/*nonNLS*/.toCharArray();
	
	// predefined constant index for well known types
	final static int JAVA_LANG_REFLECT_FIELD_TYPE = 0;
	final static int JAVA_LANG_REFLECT_METHOD_TYPE = 1;
	final static int JAVA_LANG_REFLECT_ACCESSIBLEOBJECT_TYPE = 2;
	final static int JAVA_LANG_REFLECT_ARRAY_TYPE = 3;

	// predefined constant index for well known methods
	final static int GETDECLAREDFIELD_CLASS_METHOD = 0;
	final static int SETACCESSIBLE_ACCESSIBLEOBJECT_METHOD = 1;
	final static int GET_INT_METHOD = 2;
	final static int GET_LONG_METHOD = 3;
	final static int GET_DOUBLE_METHOD = 4;
	final static int GET_FLOAT_METHOD = 5;
	final static int GET_BYTE_METHOD = 6;
	final static int GET_CHAR_METHOD = 7;
	final static int GET_BOOLEAN_METHOD = 8;
	final static int GET_OBJECT_METHOD = 9;
	final static int GET_SHORT_METHOD = 10;
	final static int SET_INT_METHOD = 11;
	final static int SET_LONG_METHOD = 12;
	final static int SET_DOUBLE_METHOD = 13;
	final static int SET_FLOAT_METHOD = 14;
	final static int SET_BYTE_METHOD = 15;
	final static int SET_CHAR_METHOD = 16;
	final static int SET_BOOLEAN_METHOD = 17;
	final static int SET_OBJECT_METHOD = 18;
	final static int SET_SHORT_METHOD = 19;
	final static int GETDECLAREDMETHOD_CLASS_METHOD = 20;
	final static int NEWINSTANCE_ARRAY_METHOD = 21;
	final static int GETCLASS_OBJECT_METHOD = 22;
	final static int INVOKE_METHOD_METHOD = 23;
	final static int BYTEVALUE_BYTE_METHOD = 24;
	final static int SHORTVALUE_SHORT_METHOD = 25;
	final static int DOUBLEVALUE_DOUBLE_METHOD = 26;
	final static int FLOATVALUE_FLOAT_METHOD = 27;
	final static int INTVALUE_INTEGER_METHOD = 28;
	final static int CHARVALUE_CHARACTER_METHOD = 29;
	final static int BOOLEANVALUE_BOOLEAN_METHOD = 30;
	final static int LONGVALUE_LONG_METHOD = 31;
	final static int GETDECLAREDCONSTRUCTOR_CLASS_METHOD = 32;
	
	// predefined constant index for well known name and type for methods
	final static int GETDECLAREDFIELD_CLASS_METHOD_NAME_AND_TYPE = 0;
	final static int SETACCESSIBLE_ACCESSIBLEOBJECT_METHOD_NAME_AND_TYPE = 1;
	final static int GET_INT_METHOD_NAME_AND_TYPE = 2;
	final static int GET_LONG_METHOD_NAME_AND_TYPE = 3;
	final static int GET_DOUBLE_METHOD_NAME_AND_TYPE = 4;
	final static int GET_FLOAT_METHOD_NAME_AND_TYPE = 5;
	final static int GET_BYTE_METHOD_NAME_AND_TYPE = 6;
	final static int GET_CHAR_METHOD_NAME_AND_TYPE = 7;
	final static int GET_BOOLEAN_METHOD_NAME_AND_TYPE = 8;
	final static int GET_OBJECT_METHOD_NAME_AND_TYPE = 9;
	final static int GET_SHORT_METHOD_NAME_AND_TYPE = 10;
	final static int SET_INT_METHOD_NAME_AND_TYPE = 11;
	final static int SET_LONG_METHOD_NAME_AND_TYPE = 12;
	final static int SET_DOUBLE_METHOD_NAME_AND_TYPE = 13;
	final static int SET_FLOAT_METHOD_NAME_AND_TYPE = 14;
	final static int SET_BYTE_METHOD_NAME_AND_TYPE = 15;
	final static int SET_CHAR_METHOD_NAME_AND_TYPE = 16;
	final static int SET_BOOLEAN_METHOD_NAME_AND_TYPE = 17;
	final static int SET_OBJECT_METHOD_NAME_AND_TYPE = 18;
	final static int SET_SHORT_METHOD_NAME_AND_TYPE = 19;
	final static int GETDECLAREDMETHOD_CLASS_METHOD_NAME_AND_TYPE = 20;
	final static int ARRAY_NEWINSTANCE_METHOD_NAME_AND_TYPE = 21;
	final static int GETCLASS_OBJECT_METHOD_NAME_AND_TYPE = 22;
	final static int INVOKE_METHOD_METHOD_NAME_AND_TYPE = 23;
	final static int BYTEVALUE_BYTE_METHOD_NAME_AND_TYPE = 24;
	final static int SHORTVALUE_SHORT_METHOD_NAME_AND_TYPE = 25;
	final static int DOUBLEVALUE_DOUBLE_METHOD_NAME_AND_TYPE = 26;
	final static int FLOATVALUE_FLOAT_METHOD_NAME_AND_TYPE = 27;
	final static int INTVALUE_INTEGER_METHOD_NAME_AND_TYPE = 28;
	final static int CHARVALUE_CHARACTER_METHOD_NAME_AND_TYPE = 29;
	final static int BOOLEANVALUE_BOOLEAN_METHOD_NAME_AND_TYPE = 30;
	final static int LONGVALUE_LONG_METHOD_NAME_AND_TYPE = 31;
	final static int GETDECLAREDCONSTRUCTOR_CLASS_METHOD_NAME_AND_TYPE = 32;
	
	int[] wellKnownTypes = new int[4];
	int[] wellKnownMethods = new int[33];
	int[] wellKnownMethodNameAndTypes = new int[33];	
/**
 * CodeSnippetConstantPool constructor comment.
 * @param classFile org.eclipse.jdt.internal.compiler.ClassFile
 */
public CodeSnippetConstantPool(org.eclipse.jdt.internal.compiler.ClassFile classFile) {
	super(classFile);
}
/**
 * Return the index of the @methodBinding.
 *
 * Returns -1 if the @methodBinding is not a predefined methodBinding, 
 * the right index otherwise.
 *
 * @param methodBinding com.ibm.compiler.namelookup.MethodBinding
 * @return <CODE>int</CODE>
 */
public int indexOfWellKnownMethodNameAndType(MethodBinding methodBinding) {
	int index = super.indexOfWellKnownMethodNameAndType(methodBinding);
	if (index == -1) {
		char firstChar = methodBinding.selector[0];
		switch(firstChar) {
			case 'g':
				if (methodBinding.parameters.length == 1
					&& methodBinding.parameters[0].id == T_JavaLangString
					&& CharOperation.equals(methodBinding.selector, GETDECLAREDFIELD_NAME)
					&& methodBinding.returnType instanceof ReferenceBinding
					&& CharOperation.equals(((ReferenceBinding) methodBinding.returnType).compoundName,JAVA_LANG_REFLECT_FIELD)) {
						return GETDECLAREDFIELD_CLASS_METHOD_NAME_AND_TYPE;
				}
				if (methodBinding.parameters.length == 2
					&& methodBinding.parameters[0].id == T_JavaLangString
					&& methodBinding.parameters[1].isArrayType()
					&& ((ArrayBinding) methodBinding.parameters[1]).leafComponentType.id == T_JavaLangClass
					&& CharOperation.equals(methodBinding.selector, GETDECLAREDMETHOD_NAME)
					&& methodBinding.returnType instanceof ReferenceBinding
					&& CharOperation.equals(((ReferenceBinding) methodBinding.returnType).compoundName,JAVA_LANG_REFLECT_METHOD)) {
						return GETDECLAREDMETHOD_CLASS_METHOD_NAME_AND_TYPE;
				}
				if (methodBinding.parameters.length == 1
					&& methodBinding.parameters[0].isArrayType()
					&& ((ArrayBinding) methodBinding.parameters[0]).leafComponentType.id == T_JavaLangClass
					&& CharOperation.equals(methodBinding.selector, GETDECLAREDCONSTRUCTOR_NAME)
					&& methodBinding.returnType instanceof ReferenceBinding
					&& CharOperation.equals(((ReferenceBinding) methodBinding.returnType).compoundName,JAVA_LANG_REFLECT_CONSTRUCTOR)) {
						return GETDECLAREDCONSTRUCTOR_CLASS_METHOD_NAME_AND_TYPE;
				}
				if (methodBinding.parameters.length == 0
					&& CharOperation.equals(methodBinding.selector, GETCLASS_OBJECT_METHOD_NAME)
					&& methodBinding.returnType.id == T_JavaLangClass) {
						return GETCLASS_OBJECT_METHOD_NAME_AND_TYPE;
				}			
				if (methodBinding.parameters.length == 1
					&& methodBinding.parameters[0].id == T_Object) {
						switch(methodBinding.returnType.id) {
							case T_int :
								if (CharOperation.equals(methodBinding.selector, GET_INT_METHOD_NAME)
									&& methodBinding.returnType.id == T_int) {
									return GET_INT_METHOD_NAME_AND_TYPE;
								}
								break;
							case T_byte :
								if (CharOperation.equals(methodBinding.selector, GET_BYTE_METHOD_NAME)
									&& methodBinding.returnType.id == T_byte) {
									return GET_BYTE_METHOD_NAME_AND_TYPE;
								}
								break;					
							case T_short :
								if (CharOperation.equals(methodBinding.selector, GET_SHORT_METHOD_NAME)
									&& methodBinding.returnType.id == T_short) {
									return GET_SHORT_METHOD_NAME_AND_TYPE;
								}
								break;
							case T_char :
								if (CharOperation.equals(methodBinding.selector, GET_CHAR_METHOD_NAME)
									&& methodBinding.returnType.id == T_char) {
									return GET_CHAR_METHOD_NAME_AND_TYPE;
								}
								break;
							case T_double :
								if (CharOperation.equals(methodBinding.selector, GET_DOUBLE_METHOD_NAME)
									&& methodBinding.returnType.id == T_double) {
									return GET_DOUBLE_METHOD_NAME_AND_TYPE;
								}
								break;
							case T_float :
								if (CharOperation.equals(methodBinding.selector, GET_FLOAT_METHOD_NAME)
									&& methodBinding.returnType.id == T_float) {
									return GET_FLOAT_METHOD_NAME_AND_TYPE;
								}
								break;
							case T_long :
								if (CharOperation.equals(methodBinding.selector, GET_LONG_METHOD_NAME)
									&& methodBinding.returnType.id == T_long) {
									return GET_LONG_METHOD_NAME_AND_TYPE;
								}
								break;
							case T_boolean :
								if (CharOperation.equals(methodBinding.selector, GET_BOOLEAN_METHOD_NAME)
									&& methodBinding.returnType.id == T_boolean) {
									return GET_BOOLEAN_METHOD_NAME_AND_TYPE;
								}
								break;
							case T_Object :
								if (CharOperation.equals(methodBinding.selector, GET_OBJECT_METHOD_NAME)
									&& methodBinding.returnType.id == T_JavaLangObject) {
									return GET_OBJECT_METHOD_NAME_AND_TYPE;
								}
						}
				}
				break;
			case 'i':
				if (methodBinding.parameters.length == 0
					&& CharOperation.equals(methodBinding.selector, INTVALUE_INTEGER_METHOD_NAME)
					&& methodBinding.returnType.id == T_int) {
						return INTVALUE_INTEGER_METHOD_NAME_AND_TYPE;
				}
				if (methodBinding.parameters.length == 2
					&& methodBinding.parameters[0].id == T_JavaLangObject
					&& methodBinding.parameters[1].isArrayType()
					&& ((ArrayBinding) methodBinding.parameters[1]).leafComponentType.id == T_JavaLangObject
					&& CharOperation.equals(methodBinding.selector, INVOKE_METHOD_METHOD_NAME)
					&& methodBinding.returnType.id == T_JavaLangObject) {
						return INVOKE_METHOD_METHOD_NAME_AND_TYPE;
				}			
				break;
			case 's':
				if (methodBinding.parameters.length == 0
					&& CharOperation.equals(methodBinding.selector, SHORTVALUE_SHORT_METHOD_NAME)
					&& methodBinding.returnType.id == T_short) {
						return SHORTVALUE_SHORT_METHOD_NAME_AND_TYPE;
				}
				if (methodBinding.parameters.length == 1
					&& methodBinding.parameters[0].id == T_boolean
					&& methodBinding.selector.length == 13
					&& CharOperation.equals(methodBinding.selector, SETACCESSIBLE_NAME)
					&& methodBinding.returnType.id == T_void) {
						return SETACCESSIBLE_ACCESSIBLEOBJECT_METHOD_NAME_AND_TYPE;
				}
				if (methodBinding.returnType.id == T_void
					&& methodBinding.parameters.length == 2
					&& methodBinding.parameters[0].id == T_Object) {
						switch(methodBinding.returnType.id) {
							case T_int :
								if (methodBinding.parameters[1].id == T_int && CharOperation.equals(methodBinding.selector, SET_INT_METHOD_NAME)
									&& methodBinding.returnType.id == T_void) {
									return SET_INT_METHOD_NAME_AND_TYPE;
								}
								break;
							case T_byte :
								if (methodBinding.parameters[1].id == T_byte && CharOperation.equals(methodBinding.selector, SET_BYTE_METHOD_NAME)
									&& methodBinding.returnType.id == T_void) {
									return SET_BYTE_METHOD_NAME_AND_TYPE;
								}
								break;					
							case T_short :
								if (methodBinding.parameters[1].id == T_short && CharOperation.equals(methodBinding.selector, SET_SHORT_METHOD_NAME)
									&& methodBinding.returnType.id == T_void) {
									return SET_SHORT_METHOD_NAME_AND_TYPE;
								}
								break;
							case T_char :
								if (methodBinding.parameters[1].id == T_char && CharOperation.equals(methodBinding.selector, SET_CHAR_METHOD_NAME)
									&& methodBinding.returnType.id == T_void) {
									return SET_CHAR_METHOD_NAME_AND_TYPE;
								}
								break;
							case T_double :
								if (methodBinding.parameters[1].id == T_double && CharOperation.equals(methodBinding.selector, SET_DOUBLE_METHOD_NAME)
									&& methodBinding.returnType.id == T_void) {
									return SET_DOUBLE_METHOD_NAME_AND_TYPE;
								}
								break;
							case T_float :
								if (methodBinding.parameters[1].id == T_float && CharOperation.equals(methodBinding.selector, SET_FLOAT_METHOD_NAME)
									&& methodBinding.returnType.id == T_void) {
									return SET_FLOAT_METHOD_NAME_AND_TYPE;
								}
								break;
							case T_long :
								if (methodBinding.parameters[1].id == T_long && CharOperation.equals(methodBinding.selector, SET_LONG_METHOD_NAME)
									&& methodBinding.returnType.id == T_void) {
									return SET_LONG_METHOD_NAME_AND_TYPE;
								}
								break;
							case T_boolean :
								if (methodBinding.parameters[1].id == T_boolean && CharOperation.equals(methodBinding.selector, SET_BOOLEAN_METHOD_NAME)
									&& methodBinding.returnType.id == T_void) {
									return SET_BOOLEAN_METHOD_NAME_AND_TYPE;
								}
								break;
							case T_Object :
								if (methodBinding.parameters[1].id == T_Object && CharOperation.equals(methodBinding.selector, SET_OBJECT_METHOD_NAME)
									&& methodBinding.returnType.id == T_void) {
									return SET_OBJECT_METHOD_NAME_AND_TYPE;
								}
						}
				}			
				break;
			case 'f':
				if (methodBinding.parameters.length == 0
					&& CharOperation.equals(methodBinding.selector, FLOATVALUE_FLOAT_METHOD_NAME)
					&& methodBinding.returnType.id == T_float) {
						return FLOATVALUE_FLOAT_METHOD_NAME_AND_TYPE;
				}
				break;
			case 'd':
				if (methodBinding.parameters.length == 0
					&& CharOperation.equals(methodBinding.selector, DOUBLEVALUE_DOUBLE_METHOD_NAME)
					&& methodBinding.returnType.id == T_double) {
						return DOUBLEVALUE_DOUBLE_METHOD_NAME_AND_TYPE;
				}
				break;
			case 'c':
				if (methodBinding.parameters.length == 0
					&& CharOperation.equals(methodBinding.selector, CHARVALUE_CHARACTER_METHOD_NAME)
					&& methodBinding.returnType.id == T_char) {
						return CHARVALUE_CHARACTER_METHOD_NAME_AND_TYPE;
				}
				break;
			case 'b':
				if (methodBinding.parameters.length == 0
					&& CharOperation.equals(methodBinding.selector, BOOLEANVALUE_BOOLEAN_METHOD_NAME)
					&& methodBinding.returnType.id == T_boolean) {
						return BOOLEANVALUE_BOOLEAN_METHOD_NAME_AND_TYPE;
				}
				if (methodBinding.parameters.length == 0
					&& CharOperation.equals(methodBinding.selector, BYTEVALUE_BYTE_METHOD_NAME)
					&& methodBinding.returnType.id == T_byte) {
						return BYTEVALUE_BYTE_METHOD_NAME_AND_TYPE;
				}
				break;
			case 'l':
				if (methodBinding.parameters.length == 0
					&& CharOperation.equals(methodBinding.selector, LONGVALUE_LONG_METHOD_NAME)
					&& methodBinding.returnType.id == T_long) {
						return LONGVALUE_LONG_METHOD_NAME_AND_TYPE;
				}
				break;
			case 'n':
				if (methodBinding.parameters.length == 2
					&& methodBinding.parameters[0].id == T_JavaLangClass
					&& methodBinding.parameters[1].isArrayType()
					&& ((ArrayBinding) methodBinding.parameters[1]).leafComponentType.id == T_int
					&& CharOperation.equals(methodBinding.selector, ARRAY_NEWINSTANCE_NAME)
					&& methodBinding.returnType instanceof ReferenceBinding
					&& CharOperation.equals(((ReferenceBinding) methodBinding.returnType).compoundName,JAVA_LANG_REFLECT_ARRAY)) {
						return ARRAY_NEWINSTANCE_METHOD_NAME_AND_TYPE;
				}
		}

	}
	return index;
}
/**
 * Return the index of the @methodBinding.
 *
 * Returns -1 if the @methodBinding is not a predefined methodBinding, 
 * the right index otherwise.
 *
 * @param methodBinding com.ibm.compiler.namelookup.MethodBinding
 * @return <CODE>int</CODE>
 */
public int indexOfWellKnownMethods(MethodBinding methodBinding) {
	int index = super.indexOfWellKnownMethods(methodBinding);
	if (index == -1) {
		char firstChar = methodBinding.selector[0];
		switch(firstChar) {
			case 'g':
				if (methodBinding.declaringClass.id == T_JavaLangClass
					&& methodBinding.parameters.length == 1
					&& methodBinding.parameters[0].id == T_JavaLangString
					&& CharOperation.equals(methodBinding.selector, GETDECLAREDFIELD_NAME)) {
						return GETDECLAREDFIELD_CLASS_METHOD;
				}
				if (methodBinding.declaringClass.id == T_JavaLangClass
					&& methodBinding.parameters.length == 2
					&& methodBinding.parameters[0].id == T_JavaLangString
					&& methodBinding.parameters[1].isArrayType()
					&& ((ArrayBinding) methodBinding.parameters[1]).leafComponentType.id == T_JavaLangClass
					&& CharOperation.equals(methodBinding.selector, GETDECLAREDMETHOD_NAME)) {
						return GETDECLAREDMETHOD_CLASS_METHOD;
				}
				if (methodBinding.declaringClass.id == T_JavaLangClass
					&& methodBinding.parameters.length == 1
					&& methodBinding.parameters[0].isArrayType()
					&& ((ArrayBinding) methodBinding.parameters[0]).leafComponentType.id == T_JavaLangClass
					&& CharOperation.equals(methodBinding.selector, GETDECLAREDCONSTRUCTOR_NAME)) {
						return GETDECLAREDCONSTRUCTOR_CLASS_METHOD;
				}
				if (methodBinding.declaringClass.id == T_JavaLangObject
					&& methodBinding.parameters.length == 0
					&& CharOperation.equals(methodBinding.selector, GETCLASS_OBJECT_METHOD_NAME)) {
						return GETCLASS_OBJECT_METHOD;
				}			
				if (CharOperation.equals(methodBinding.declaringClass.compoundName, JAVA_LANG_REFLECT_FIELD)
					&& methodBinding.parameters.length == 1
					&& methodBinding.parameters[0].id == T_Object) {
						switch(methodBinding.returnType.id) {
							case T_int :
								if (CharOperation.equals(methodBinding.selector, GET_INT_METHOD_NAME)) {
									return GET_INT_METHOD;
								}
								break;
							case T_byte :
								if (CharOperation.equals(methodBinding.selector, GET_BYTE_METHOD_NAME)) {
									return GET_BYTE_METHOD;
								}
								break;					
							case T_short :
								if (CharOperation.equals(methodBinding.selector, GET_SHORT_METHOD_NAME)) {
									return GET_SHORT_METHOD;
								}
								break;
							case T_char :
								if (CharOperation.equals(methodBinding.selector, GET_CHAR_METHOD_NAME)) {
									return GET_CHAR_METHOD;
								}
								break;
							case T_double :
								if (CharOperation.equals(methodBinding.selector, GET_DOUBLE_METHOD_NAME)) {
									return GET_DOUBLE_METHOD;
								}
								break;
							case T_float :
								if (CharOperation.equals(methodBinding.selector, GET_FLOAT_METHOD_NAME)) {
									return GET_FLOAT_METHOD;
								}
								break;
							case T_long :
								if (CharOperation.equals(methodBinding.selector, GET_LONG_METHOD_NAME)) {
									return GET_LONG_METHOD;
								}
								break;
							case T_boolean :
								if (CharOperation.equals(methodBinding.selector, GET_BOOLEAN_METHOD_NAME)) {
									return GET_BOOLEAN_METHOD;
								}
								break;
							case T_Object :
								if (CharOperation.equals(methodBinding.selector, GET_OBJECT_METHOD_NAME)) {
									return GET_OBJECT_METHOD;
								}
						}
				}
				break;
			case 'i':
				if (methodBinding.declaringClass.id == T_JavaLangInteger
					&& methodBinding.parameters.length == 0
					&& CharOperation.equals(methodBinding.selector, INTVALUE_INTEGER_METHOD_NAME)) {
						return INTVALUE_INTEGER_METHOD;
				}
				if (CharOperation.equals(methodBinding.declaringClass.compoundName, JAVA_LANG_REFLECT_METHOD)
					&& methodBinding.parameters.length == 2
					&& methodBinding.parameters[0].id == T_JavaLangObject
					&& methodBinding.parameters[1].isArrayType()
					&& ((ArrayBinding) methodBinding.parameters[1]).leafComponentType.id == T_JavaLangObject
					&& CharOperation.equals(methodBinding.selector, INVOKE_METHOD_METHOD_NAME)) {
						return INVOKE_METHOD_METHOD;
				}			
				break;
			case 'b':
				if (methodBinding.declaringClass.id == T_JavaLangByte
					&& methodBinding.parameters.length == 0
					&& CharOperation.equals(methodBinding.selector, BYTEVALUE_BYTE_METHOD_NAME)) {
						return BYTEVALUE_BYTE_METHOD;
				}
				if (methodBinding.declaringClass.id == T_JavaLangBoolean
					&& methodBinding.parameters.length == 0
					&& CharOperation.equals(methodBinding.selector, BOOLEANVALUE_BOOLEAN_METHOD_NAME)) {
						return BOOLEANVALUE_BOOLEAN_METHOD;
				}
				break;
			case 's': 				
				if (methodBinding.declaringClass.id == T_JavaLangShort
					&& methodBinding.parameters.length == 0
					&& CharOperation.equals(methodBinding.selector, SHORTVALUE_SHORT_METHOD_NAME)) {
						return SHORTVALUE_SHORT_METHOD;
				}
				if (CharOperation.equals(methodBinding.declaringClass.compoundName, JAVA_LANG_REFLECT_ACCESSIBLEOBJECT)
					&& methodBinding.parameters.length == 1
					&& methodBinding.parameters[0].id == T_boolean
					&& methodBinding.selector.length == 13
					&& CharOperation.equals(methodBinding.selector, SETACCESSIBLE_NAME)) {
						return SETACCESSIBLE_ACCESSIBLEOBJECT_METHOD;
				}
				if (CharOperation.equals(methodBinding.declaringClass.compoundName, JAVA_LANG_REFLECT_FIELD)
					&& methodBinding.returnType.id == T_void
					&& methodBinding.parameters.length == 2
					&& methodBinding.parameters[0].id == T_Object) {
						switch(methodBinding.returnType.id) {
							case T_int :
								if (methodBinding.parameters[1].id == T_int && CharOperation.equals(methodBinding.selector, SET_INT_METHOD_NAME)) {
									return SET_INT_METHOD;
								}
								break;
							case T_byte :
								if (methodBinding.parameters[1].id == T_byte && CharOperation.equals(methodBinding.selector, SET_BYTE_METHOD_NAME)) {
									return SET_BYTE_METHOD;
								}
								break;					
							case T_short :
								if (methodBinding.parameters[1].id == T_short && CharOperation.equals(methodBinding.selector, SET_SHORT_METHOD_NAME)) {
									return SET_SHORT_METHOD;
								}
								break;
							case T_char :
								if (methodBinding.parameters[1].id == T_char && CharOperation.equals(methodBinding.selector, SET_CHAR_METHOD_NAME)) {
									return SET_CHAR_METHOD;
								}
								break;
							case T_double :
								if (methodBinding.parameters[1].id == T_double && CharOperation.equals(methodBinding.selector, SET_DOUBLE_METHOD_NAME)) {
									return SET_DOUBLE_METHOD;
								}
								break;
							case T_float :
								if (methodBinding.parameters[1].id == T_float && CharOperation.equals(methodBinding.selector, SET_FLOAT_METHOD_NAME)) {
									return SET_FLOAT_METHOD;
								}
								break;
							case T_long :
								if (methodBinding.parameters[1].id == T_long && CharOperation.equals(methodBinding.selector, SET_LONG_METHOD_NAME)) {
									return SET_LONG_METHOD;
								}
								break;
							case T_boolean :
								if (methodBinding.parameters[1].id == T_boolean && CharOperation.equals(methodBinding.selector, SET_BOOLEAN_METHOD_NAME)) {
									return SET_BOOLEAN_METHOD;
								}
								break;
							case T_Object :
								if (methodBinding.parameters[1].id == T_Object && CharOperation.equals(methodBinding.selector, SET_OBJECT_METHOD_NAME)) {
									return SET_OBJECT_METHOD;
								}
						}
				}			
				break;
			case 'f':
				if (methodBinding.declaringClass.id == T_JavaLangFloat
					&& methodBinding.parameters.length == 0
					&& CharOperation.equals(methodBinding.selector, FLOATVALUE_FLOAT_METHOD_NAME)) {
						return FLOATVALUE_FLOAT_METHOD;
				}
				break;
			case 'd':
				if (methodBinding.declaringClass.id == T_JavaLangDouble
					&& methodBinding.parameters.length == 0
					&& CharOperation.equals(methodBinding.selector, DOUBLEVALUE_DOUBLE_METHOD_NAME)) {
						return DOUBLEVALUE_DOUBLE_METHOD;
				}
				break;
			case 'c':
				if (methodBinding.declaringClass.id == T_JavaLangCharacter
					&& methodBinding.parameters.length == 0
					&& CharOperation.equals(methodBinding.selector, CHARVALUE_CHARACTER_METHOD_NAME)) {
						return CHARVALUE_CHARACTER_METHOD;
				}
				break;
			case 'l':
				if (methodBinding.declaringClass.id == T_JavaLangLong
					&& methodBinding.parameters.length == 0
					&& CharOperation.equals(methodBinding.selector, LONGVALUE_LONG_METHOD_NAME)) {
						return LONGVALUE_LONG_METHOD;
				}
				break;
			case 'n':
				if (CharOperation.equals(methodBinding.declaringClass.compoundName, JAVA_LANG_REFLECT_ARRAY)
					&& methodBinding.parameters.length == 2
					&& methodBinding.parameters[0].id == T_JavaLangClass
					&& methodBinding.parameters[1].isArrayType()
					&& ((ArrayBinding) methodBinding.parameters[1]).leafComponentType.id == T_int
					&& CharOperation.equals(methodBinding.selector, ARRAY_NEWINSTANCE_NAME)) {
						return NEWINSTANCE_ARRAY_METHOD;
				}
				break;
		}
	}
	return index;
}
/**
 * Return the index of the @typeBinding
 *
 * Returns -1 if the @typeBinding is not a predefined binding, the right index 
 * otherwise.
 *
 * @param typeBinding com.ibm.compiler.namelookup.TypeBinding
 * @return <CODE>int</CODE>
 */
public int indexOfWellKnownTypes(TypeBinding typeBinding) {
	int index = super.indexOfWellKnownTypes(typeBinding);
	if (index == -1) {
		if (!typeBinding.isBaseType() && !typeBinding.isArrayType()) {
			ReferenceBinding type = (ReferenceBinding) typeBinding;
			if (type.compoundName.length == 4) {
				if (CharOperation.equals(JAVA_LANG_REFLECT_FIELD, type.compoundName)) {
					return JAVA_LANG_REFLECT_FIELD_TYPE;
				}
				if (CharOperation.equals(JAVA_LANG_REFLECT_METHOD, type.compoundName)) {
					return JAVA_LANG_REFLECT_METHOD_TYPE;
				}
				if (CharOperation.equals(JAVA_LANG_REFLECT_ARRAY, type.compoundName)) {
					return JAVA_LANG_REFLECT_ARRAY_TYPE;
				}
				if (CharOperation.equals(JAVA_LANG_REFLECT_ACCESSIBLEOBJECT, type.compoundName)) {
					return JAVA_LANG_REFLECT_ACCESSIBLEOBJECT_TYPE;
				}
			}
		}
	}
	return index;
}
/**
 * This method returns the index into the constantPool corresponding to the 
 * method descriptor. It can be either an interface method reference constant
 * or a method reference constant.
 *
 * @param MethodBinding aMethodBinding
 * @return <CODE>int</CODE>
 */
public int literalIndex(MethodBinding aMethodBinding) {
	int index;
	int nameAndTypeIndex;
	int classIndex;
	int nameIndex;
	int indexWellKnownMethod;
	if ((indexWellKnownMethod = super.indexOfWellKnownMethods(aMethodBinding)) == -1) {
		if ((indexWellKnownMethod = indexOfWellKnownMethods(aMethodBinding)) == -1) {
			if (aMethodBinding.declaringClass.isInterface()) {
				// Lookinf into the interface method ref table
				if ((index = interfaceMethodCache.get(aMethodBinding)) < 0) {
					classIndex = literalIndex(aMethodBinding.declaringClass);
					nameAndTypeIndex =
						literalIndexForMethods(
							literalIndex(aMethodBinding.constantPoolName()),
							literalIndex(aMethodBinding.signature()),
							aMethodBinding);
					index = interfaceMethodCache.put(aMethodBinding, currentIndex++);
					// Write the interface method ref constant into the constant pool
					// First add the tag
					writeU1(InterfaceMethodRefTag);
					// Then write the class index
					writeU2(classIndex);
					// The write the nameAndType index
					writeU2(nameAndTypeIndex);
				}
			} else {
				// Lookinf into the method ref table
				if ((index = methodCache.get(aMethodBinding)) < 0) {
					classIndex = literalIndex(aMethodBinding.declaringClass);
					nameAndTypeIndex =
						literalIndexForMethods(
							literalIndex(aMethodBinding.constantPoolName()),
							literalIndex(aMethodBinding.signature()),
							aMethodBinding);
					index = methodCache.put(aMethodBinding, currentIndex++);
					// Write the method ref constant into the constant pool
					// First add the tag
					writeU1(MethodRefTag);
					// Then write the class index
					writeU2(classIndex);
					// The write the nameAndType index
					writeU2(nameAndTypeIndex);
				}
			}
		} else {
			// This is a well known method
			if ((index = wellKnownMethods[indexWellKnownMethod]) == 0) {
				// this methods was not inserted yet
				if (aMethodBinding.declaringClass.isInterface()) {
					// Lookinf into the interface method ref table
					classIndex = literalIndex(aMethodBinding.declaringClass);
					nameAndTypeIndex =
						literalIndexForMethods(
							literalIndex(aMethodBinding.constantPoolName()),
							literalIndex(aMethodBinding.signature()),
							aMethodBinding);
					index = wellKnownMethods[indexWellKnownMethod] = currentIndex++;
					// Write the interface method ref constant into the constant pool
					// First add the tag
					writeU1(InterfaceMethodRefTag);
					// Then write the class index
					writeU2(classIndex);
					// The write the nameAndType index
					writeU2(nameAndTypeIndex);
				} else {
					// Lookinf into the method ref table
					classIndex = literalIndex(aMethodBinding.declaringClass);
					nameAndTypeIndex =
						literalIndexForMethods(
							literalIndex(aMethodBinding.constantPoolName()),
							literalIndex(aMethodBinding.signature()),
							aMethodBinding);
					index = wellKnownMethods[indexWellKnownMethod] = currentIndex++;
					// Write the method ref constant into the constant pool
					// First add the tag
					writeU1(MethodRefTag);
					// Then write the class index
					writeU2(classIndex);
					// The write the nameAndType index
					writeU2(nameAndTypeIndex);
				}
			}
		}
	} else {
		index = super.literalIndex(aMethodBinding);
	}
	return index;
}
/**
 * This method returns the index into the constantPool corresponding to the type descriptor.
 *
 * @param TypeBinding aTypeBinding
 * @return <CODE>int</CODE>
 */
public int literalIndex(TypeBinding aTypeBinding) {
	int index;
	int nameIndex;
	int indexWellKnownType;
	if ((indexWellKnownType = super.indexOfWellKnownTypes(aTypeBinding)) == -1) {
		if ((indexWellKnownType = indexOfWellKnownTypes(aTypeBinding)) == -1) {
			if ((index = classCache.get(aTypeBinding)) < 0) {
				// The entry doesn't exit yet
				nameIndex = literalIndex(aTypeBinding.constantPoolName());
				index = classCache.put(aTypeBinding, currentIndex++);
				writeU1(ClassTag);
				// Then add the 8 bytes representing the long
				writeU2(nameIndex);
			}
		} else {
			if ((index = wellKnownTypes[indexWellKnownType]) == 0) {
				// Need to insert that binding
				nameIndex = literalIndex(aTypeBinding.constantPoolName());
				index = wellKnownTypes[indexWellKnownType] = currentIndex++;
				writeU1(ClassTag);
				// Then add the 8 bytes representing the long
				writeU2(nameIndex);
			}
		}
	} else {
		index = super.literalIndex(aTypeBinding);
	}
	return index;
}
/**
 * This method returns the index into the constantPool corresponding to the 
 * method descriptor. It can be either an interface method reference constant
 * or a method reference constant.
 *
 * @return <CODE>int</CODE>
 */
public int literalIndexForJavaLangBooleanBooleanValue() {
	int index;
	int nameAndTypeIndex;
	int classIndex;
	// Looking into the method ref table
	if ((index = wellKnownMethods[BOOLEANVALUE_BOOLEAN_METHOD]) == 0) {
		classIndex = literalIndexForJavaLangBoolean();
		if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[BOOLEANVALUE_BOOLEAN_METHOD_NAME_AND_TYPE]) == 0) {
			int nameIndex = literalIndex(BOOLEANVALUE_BOOLEAN_METHOD_NAME);
			int typeIndex = literalIndex(BOOLEANVALUE_BOOLEAN_METHOD_SIGNATURE);
			nameAndTypeIndex = wellKnownMethodNameAndTypes[BOOLEANVALUE_BOOLEAN_METHOD_NAME_AND_TYPE] = currentIndex++;
			writeU1(NameAndTypeTag);
			writeU2(nameIndex);
			writeU2(typeIndex);
		}
		index = wellKnownMethods[BOOLEANVALUE_BOOLEAN_METHOD_NAME_AND_TYPE] = currentIndex++;
		// Write the method ref constant into the constant pool
		// First add the tag
		writeU1(MethodRefTag);
		// Then write the class index
		writeU2(classIndex);
		// The write the nameAndType index
		writeU2(nameAndTypeIndex);
	}
	return index;
}
/**
 * This method returns the index into the constantPool corresponding to the 
 * method descriptor. It can be either an interface method reference constant
 * or a method reference constant.
 *
 * @return <CODE>int</CODE>
 */
public int literalIndexForJavaLangByteByteValue() {
	int index;
	int nameAndTypeIndex;
	int classIndex;
	// Looking into the method ref table
	if ((index = wellKnownMethods[BYTEVALUE_BYTE_METHOD]) == 0) {
		classIndex = literalIndexForJavaLangByte();
		if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[BYTEVALUE_BYTE_METHOD_NAME_AND_TYPE]) == 0) {
			int nameIndex = literalIndex(BYTEVALUE_BYTE_METHOD_NAME);
			int typeIndex = literalIndex(BYTEVALUE_BYTE_METHOD_SIGNATURE);
			nameAndTypeIndex = wellKnownMethodNameAndTypes[BYTEVALUE_BYTE_METHOD_NAME_AND_TYPE] = currentIndex++;
			writeU1(NameAndTypeTag);
			writeU2(nameIndex);
			writeU2(typeIndex);
		}
		index = wellKnownMethods[BYTEVALUE_BYTE_METHOD] = currentIndex++;
		// Write the method ref constant into the constant pool
		// First add the tag
		writeU1(MethodRefTag);
		// Then write the class index
		writeU2(classIndex);
		// The write the nameAndType index
		writeU2(nameAndTypeIndex);
	}
	return index;
}
/**
 * This method returns the index into the constantPool corresponding to the 
 * method descriptor. It can be either an interface method reference constant
 * or a method reference constant.
 *
 * @return <CODE>int</CODE>
 */
public int literalIndexForJavaLangCharacterCharValue() {
	int index;
	int nameAndTypeIndex;
	int classIndex;
	// Looking into the method ref table
	if ((index = wellKnownMethods[CHARVALUE_CHARACTER_METHOD]) == 0) {
		classIndex = literalIndexForJavaLangCharacter();
		if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[CHARVALUE_CHARACTER_METHOD_NAME_AND_TYPE]) == 0) {
			int nameIndex = literalIndex(CHARVALUE_CHARACTER_METHOD_NAME);
			int typeIndex = literalIndex(CHARVALUE_CHARACTER_METHOD_SIGNATURE);
			nameAndTypeIndex = wellKnownMethodNameAndTypes[CHARVALUE_CHARACTER_METHOD_NAME_AND_TYPE] = currentIndex++;
			writeU1(NameAndTypeTag);
			writeU2(nameIndex);
			writeU2(typeIndex);
		}
		index = wellKnownMethods[CHARVALUE_CHARACTER_METHOD] = currentIndex++;
		// Write the method ref constant into the constant pool
		// First add the tag
		writeU1(MethodRefTag);
		// Then write the class index
		writeU2(classIndex);
		// The write the nameAndType index
		writeU2(nameAndTypeIndex);
	}
	return index;
}
/**
 * This method returns the index into the constantPool corresponding to the 
 * method descriptor. It can be either an interface method reference constant
 * or a method reference constant.
 *
 * @return <CODE>int</CODE>
 */
public int literalIndexForJavaLangClassGetDeclaredConstructor() {
	int index;
	int nameAndTypeIndex;
	int classIndex;
	// Looking into the method ref table
	if ((index = wellKnownMethods[GETDECLAREDCONSTRUCTOR_CLASS_METHOD]) == 0) {
		classIndex = literalIndexForJavaLangClass();
		if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[GETDECLAREDCONSTRUCTOR_CLASS_METHOD_NAME_AND_TYPE]) == 0) {
			int nameIndex = literalIndex(GETDECLAREDCONSTRUCTOR_NAME);
			int typeIndex = literalIndex(GETDECLAREDCONSTRUCTOR_SIGNATURE);
			nameAndTypeIndex = wellKnownMethodNameAndTypes[GETDECLAREDCONSTRUCTOR_CLASS_METHOD_NAME_AND_TYPE] = currentIndex++;
			writeU1(NameAndTypeTag);
			writeU2(nameIndex);
			writeU2(typeIndex);
		}
		index = wellKnownMethods[GETDECLAREDCONSTRUCTOR_CLASS_METHOD] = currentIndex++;
		// Write the method ref constant into the constant pool
		// First add the tag
		writeU1(MethodRefTag);
		// Then write the class index
		writeU2(classIndex);
		// The write the nameAndType index
		writeU2(nameAndTypeIndex);
	}
	return index;
}
/**
 * This method returns the index into the constantPool corresponding to the 
 * method descriptor. It can be either an interface method reference constant
 * or a method reference constant.
 *
 * @return <CODE>int</CODE>
 */
public int literalIndexForJavaLangClassGetDeclaredField() {
	int index;
	int nameAndTypeIndex;
	int classIndex;
	// Looking into the method ref table
	if ((index = wellKnownMethods[GETDECLAREDFIELD_CLASS_METHOD]) == 0) {
		classIndex = literalIndexForJavaLangClass();
		if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[GETDECLAREDFIELD_CLASS_METHOD_NAME_AND_TYPE]) == 0) {
			int nameIndex = literalIndex(GETDECLAREDFIELD_NAME);
			int typeIndex = literalIndex(GETDECLAREDFIELD_SIGNATURE);
			nameAndTypeIndex = wellKnownMethodNameAndTypes[GETDECLAREDFIELD_CLASS_METHOD_NAME_AND_TYPE] = currentIndex++;
			writeU1(NameAndTypeTag);
			writeU2(nameIndex);
			writeU2(typeIndex);
		}
		index = wellKnownMethods[GETDECLAREDFIELD_CLASS_METHOD] = currentIndex++;
		// Write the method ref constant into the constant pool
		// First add the tag
		writeU1(MethodRefTag);
		// Then write the class index
		writeU2(classIndex);
		// The write the nameAndType index
		writeU2(nameAndTypeIndex);
	}
	return index;
}
/**
 * This method returns the index into the constantPool corresponding to the 
 * method descriptor. It can be either an interface method reference constant
 * or a method reference constant.
 *
 * @return <CODE>int</CODE>
 */
public int literalIndexForJavaLangClassGetDeclaredMethod() {
	int index;
	int nameAndTypeIndex;
	int classIndex;
	// Looking into the method ref table
	if ((index = wellKnownMethods[GETDECLAREDMETHOD_CLASS_METHOD]) == 0) {
		classIndex = literalIndexForJavaLangClass();
		if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[GETDECLAREDMETHOD_CLASS_METHOD_NAME_AND_TYPE]) == 0) {
			int nameIndex = literalIndex(GETDECLAREDMETHOD_NAME);
			int typeIndex = literalIndex(GETDECLAREDMETHOD_SIGNATURE);
			nameAndTypeIndex = wellKnownMethodNameAndTypes[GETDECLAREDMETHOD_CLASS_METHOD_NAME_AND_TYPE] = currentIndex++;
			writeU1(NameAndTypeTag);
			writeU2(nameIndex);
			writeU2(typeIndex);
		}
		index = wellKnownMethods[GETDECLAREDMETHOD_CLASS_METHOD] = currentIndex++;
		// Write the method ref constant into the constant pool
		// First add the tag
		writeU1(MethodRefTag);
		// Then write the class index
		writeU2(classIndex);
		// The write the nameAndType index
		writeU2(nameAndTypeIndex);
	}
	return index;
}
/**
 * This method returns the index into the constantPool corresponding to the 
 * method descriptor. It can be either an interface method reference constant
 * or a method reference constant.
 *
 * @return <CODE>int</CODE>
 */
public int literalIndexForJavaLangDoubleDoubleValue() {
	int index;
	int nameAndTypeIndex;
	int classIndex;
	// Looking into the method ref table
	if ((index = wellKnownMethods[DOUBLEVALUE_DOUBLE_METHOD]) == 0) {
		classIndex = literalIndexForJavaLangDouble();
		if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[DOUBLEVALUE_DOUBLE_METHOD_NAME_AND_TYPE]) == 0) {
			int nameIndex = literalIndex(DOUBLEVALUE_DOUBLE_METHOD_NAME);
			int typeIndex = literalIndex(DOUBLEVALUE_DOUBLE_METHOD_SIGNATURE);
			nameAndTypeIndex = wellKnownMethodNameAndTypes[DOUBLEVALUE_DOUBLE_METHOD_NAME_AND_TYPE] = currentIndex++;
			writeU1(NameAndTypeTag);
			writeU2(nameIndex);
			writeU2(typeIndex);
		}
		index = wellKnownMethods[DOUBLEVALUE_DOUBLE_METHOD] = currentIndex++;
		// Write the method ref constant into the constant pool
		// First add the tag
		writeU1(MethodRefTag);
		// Then write the class index
		writeU2(classIndex);
		// The write the nameAndType index
		writeU2(nameAndTypeIndex);
	}
	return index;
}
/**
 * This method returns the index into the constantPool corresponding to the 
 * method descriptor. It can be either an interface method reference constant
 * or a method reference constant.
 *
 * @return <CODE>int</CODE>
 */
public int literalIndexForJavaLangFloatFloatValue() {
	int index;
	int nameAndTypeIndex;
	int classIndex;
	// Looking into the method ref table
	if ((index = wellKnownMethods[FLOATVALUE_FLOAT_METHOD]) == 0) {
		classIndex = literalIndexForJavaLangFloat();
		if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[FLOATVALUE_FLOAT_METHOD_NAME_AND_TYPE]) == 0) {
			int nameIndex = literalIndex(FLOATVALUE_FLOAT_METHOD_NAME);
			int typeIndex = literalIndex(FLOATVALUE_FLOAT_METHOD_SIGNATURE);
			nameAndTypeIndex = wellKnownMethodNameAndTypes[FLOATVALUE_FLOAT_METHOD_NAME_AND_TYPE] = currentIndex++;
			writeU1(NameAndTypeTag);
			writeU2(nameIndex);
			writeU2(typeIndex);
		}
		index = wellKnownMethods[FLOATVALUE_FLOAT_METHOD] = currentIndex++;
		// Write the method ref constant into the constant pool
		// First add the tag
		writeU1(MethodRefTag);
		// Then write the class index
		writeU2(classIndex);
		// The write the nameAndType index
		writeU2(nameAndTypeIndex);
	}
	return index;
}
/**
 * This method returns the index into the constantPool corresponding to the 
 * method descriptor. It can be either an interface method reference constant
 * or a method reference constant.
 *
 * @return <CODE>int</CODE>
 */
public int literalIndexForJavaLangIntegerIntValue() {
	int index;
	int nameAndTypeIndex;
	int classIndex;
	// Looking into the method ref table
	if ((index = wellKnownMethods[INTVALUE_INTEGER_METHOD]) == 0) {
		classIndex = literalIndexForJavaLangInteger();
		if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[INTVALUE_INTEGER_METHOD_NAME_AND_TYPE]) == 0) {
			int nameIndex = literalIndex(INTVALUE_INTEGER_METHOD_NAME);
			int typeIndex = literalIndex(INTVALUE_INTEGER_METHOD_SIGNATURE);
			nameAndTypeIndex = wellKnownMethodNameAndTypes[INTVALUE_INTEGER_METHOD_NAME_AND_TYPE] = currentIndex++;
			writeU1(NameAndTypeTag);
			writeU2(nameIndex);
			writeU2(typeIndex);
		}
		index = wellKnownMethods[INTVALUE_INTEGER_METHOD] = currentIndex++;
		// Write the method ref constant into the constant pool
		// First add the tag
		writeU1(MethodRefTag);
		// Then write the class index
		writeU2(classIndex);
		// The write the nameAndType index
		writeU2(nameAndTypeIndex);
	}
	return index;
}
/**
 * This method returns the index into the constantPool corresponding to the 
 * method descriptor. It can be either an interface method reference constant
 * or a method reference constant.
 *
 * @return <CODE>int</CODE>
 */
public int literalIndexForJavaLangLongLongValue() {
	int index;
	int nameAndTypeIndex;
	int classIndex;
	// Looking into the method ref table
	if ((index = wellKnownMethods[LONGVALUE_LONG_METHOD]) == 0) {
		classIndex = literalIndexForJavaLangLong();
		if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[LONGVALUE_LONG_METHOD_NAME_AND_TYPE]) == 0) {
			int nameIndex = literalIndex(LONGVALUE_LONG_METHOD_NAME);
			int typeIndex = literalIndex(LONGVALUE_LONG_METHOD_SIGNATURE);
			nameAndTypeIndex = wellKnownMethodNameAndTypes[LONGVALUE_LONG_METHOD_NAME_AND_TYPE] = currentIndex++;
			writeU1(NameAndTypeTag);
			writeU2(nameIndex);
			writeU2(typeIndex);
		}
		index = wellKnownMethods[LONGVALUE_LONG_METHOD] = currentIndex++;
		// Write the method ref constant into the constant pool
		// First add the tag
		writeU1(MethodRefTag);
		// Then write the class index
		writeU2(classIndex);
		// The write the nameAndType index
		writeU2(nameAndTypeIndex);
	}
	return index;
}
/**
 * This method returns the index into the constantPool corresponding to the 
 * method descriptor. It can be either an interface method reference constant
 * or a method reference constant.
 *
 * @return <CODE>int</CODE>
 */
public int literalIndexForJavaLangObjectGetClass() {
	int index;
	int nameAndTypeIndex;
	int classIndex;
	// Looking into the method ref table
	if ((index = wellKnownMethods[GETCLASS_OBJECT_METHOD]) == 0) {
		classIndex = literalIndexForJavaLangObject();
		if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[GETCLASS_OBJECT_METHOD_NAME_AND_TYPE]) == 0) {
			int nameIndex = literalIndex(GETCLASS_OBJECT_METHOD_NAME);
			int typeIndex = literalIndex(GETCLASS_OBJECT_METHOD_SIGNATURE);
			nameAndTypeIndex = wellKnownMethodNameAndTypes[GETCLASS_OBJECT_METHOD_NAME_AND_TYPE] = currentIndex++;
			writeU1(NameAndTypeTag);
			writeU2(nameIndex);
			writeU2(typeIndex);
		}
		index = wellKnownMethods[GETCLASS_OBJECT_METHOD] = currentIndex++;
		// Write the method ref constant into the constant pool
		// First add the tag
		writeU1(MethodRefTag);
		// Then write the class index
		writeU2(classIndex);
		// The write the nameAndType index
		writeU2(nameAndTypeIndex);
	}
	return index;
}
/**
 * This method returns the index into the constantPool corresponding to the 
 * method descriptor. It can be either an interface method reference constant
 * or a method reference constant.
 *
 * @return <CODE>int</CODE>
 */
public int literalIndexForJavaLangReflectAccessibleObject() {
	int index;
	if ((index = wellKnownTypes[JAVA_LANG_REFLECT_ACCESSIBLEOBJECT_TYPE]) == 0) {
		int nameIndex;
		// The entry doesn't exit yet
		nameIndex = literalIndex(JAVALANGREFLECTACCESSIBLEOBJECT_CONSTANTPOOLNAME);
		index = wellKnownTypes[JAVA_LANG_REFLECT_ACCESSIBLEOBJECT_TYPE] = currentIndex++;
		writeU1(ClassTag);
		// Then add the 8 bytes representing the long
		writeU2(nameIndex);
	}
	return index;
}
/**
 * This method returns the index into the constantPool corresponding to the 
 * method descriptor. It can be either an interface method reference constant
 * or a method reference constant.
 *
 * @return <CODE>int</CODE>
 */
public int literalIndexForJavaLangReflectAccessibleObjectSetAccessible() {
	int index;
	int nameAndTypeIndex;
	int classIndex;
	// Looking into the method ref table
	if ((index = wellKnownMethods[SETACCESSIBLE_ACCESSIBLEOBJECT_METHOD]) == 0) {
		classIndex = literalIndexForJavaLangReflectAccessibleObject();
		if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[SETACCESSIBLE_ACCESSIBLEOBJECT_METHOD_NAME_AND_TYPE]) == 0) {
			int nameIndex = literalIndex(SETACCESSIBLE_NAME);
			int typeIndex = literalIndex(SETACCESSIBLE_SIGNATURE);
			nameAndTypeIndex = wellKnownMethodNameAndTypes[SETACCESSIBLE_ACCESSIBLEOBJECT_METHOD_NAME_AND_TYPE] = currentIndex++;
			writeU1(NameAndTypeTag);
			writeU2(nameIndex);
			writeU2(typeIndex);
		}
		index = wellKnownMethods[SETACCESSIBLE_ACCESSIBLEOBJECT_METHOD] = currentIndex++;
		// Write the method ref constant into the constant pool
		// First add the tag
		writeU1(MethodRefTag);
		// Then write the class index
		writeU2(classIndex);
		// The write the nameAndType index
		writeU2(nameAndTypeIndex);
	}
	return index;
}
/**
 * This method returns the index into the constantPool corresponding to the 
 * method descriptor. It can be either an interface method reference constant
 * or a method reference constant.
 *
 * @return <CODE>int</CODE>
 */
public int literalIndexForJavaLangReflectArray() {
	int index;
	if ((index = wellKnownTypes[JAVA_LANG_REFLECT_ARRAY_TYPE]) == 0) {
		int nameIndex;
		// The entry doesn't exit yet
		nameIndex = literalIndex(JAVALANGREFLECTARRAY_CONSTANTPOOLNAME);
		index = wellKnownTypes[JAVA_LANG_REFLECT_ARRAY_TYPE] = currentIndex++;
		writeU1(ClassTag);
		// Then add the 8 bytes representing the long
		writeU2(nameIndex);
	}
	return index;
}
/**
 * This method returns the index into the constantPool corresponding to the 
 * method descriptor. It can be either an interface method reference constant
 * or a method reference constant.
 *
 * @return <CODE>int</CODE>
 */
public int literalIndexForJavaLangReflectArrayNewInstance() {
	int index;
	int nameAndTypeIndex;
	int classIndex;
	// Looking into the method ref table
	if ((index = wellKnownMethods[NEWINSTANCE_ARRAY_METHOD]) == 0) {
		classIndex = literalIndexForJavaLangReflectArray();
		if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[ARRAY_NEWINSTANCE_METHOD_NAME_AND_TYPE]) == 0) {
			int nameIndex = literalIndex(ARRAY_NEWINSTANCE_NAME);
			int typeIndex = literalIndex(ARRAY_NEWINSTANCE_SIGNATURE);
			nameAndTypeIndex = wellKnownMethodNameAndTypes[ARRAY_NEWINSTANCE_METHOD_NAME_AND_TYPE] = currentIndex++;
			writeU1(NameAndTypeTag);
			writeU2(nameIndex);
			writeU2(typeIndex);
		}
		index = wellKnownMethods[NEWINSTANCE_ARRAY_METHOD] = currentIndex++;
		// Write the method ref constant into the constant pool
		// First add the tag
		writeU1(MethodRefTag);
		// Then write the class index
		writeU2(classIndex);
		// The write the nameAndType index
		writeU2(nameAndTypeIndex);
	}
	return index;
}
/**
 * This method returns the index into the constantPool corresponding to the 
 * method descriptor. It can be either an interface method reference constant
 * or a method reference constant.
 *
 * @return <CODE>int</CODE>
 */
public int literalIndexForJavaLangReflectField() {
	int index;
	if ((index = wellKnownTypes[JAVA_LANG_REFLECT_FIELD_TYPE]) == 0) {
		int nameIndex;
		// The entry doesn't exit yet
		nameIndex = literalIndex(JAVALANGREFLECTFIELD_CONSTANTPOOLNAME);
		index = wellKnownTypes[JAVA_LANG_REFLECT_FIELD_TYPE] = currentIndex++;
		writeU1(ClassTag);
		// Then add the 8 bytes representing the long
		writeU2(nameIndex);
	}
	return index;
}
/**
 * This method returns the index into the constantPool corresponding to the 
 * method descriptor. It can be either an interface method reference constant
 * or a method reference constant.
 *
 * @return <CODE>int</CODE>
 */
public int literalIndexForJavaLangReflectMethod() {
	int index;
	if ((index = wellKnownTypes[JAVA_LANG_REFLECT_METHOD_TYPE]) == 0) {
		int nameIndex;
		// The entry doesn't exit yet
		nameIndex = literalIndex(JAVALANGREFLECTMETHOD_CONSTANTPOOLNAME);
		index = wellKnownTypes[JAVA_LANG_REFLECT_METHOD_TYPE] = currentIndex++;
		writeU1(ClassTag);
		// Then add the 8 bytes representing the long
		writeU2(nameIndex);
	}
	return index;
}
/**
 * This method returns the index into the constantPool corresponding to the 
 * method descriptor. It can be either an interface method reference constant
 * or a method reference constant.
 *
 * @return <CODE>int</CODE>
 */
public int literalIndexForJavaLangReflectMethodInvoke() {
	int index;
	int nameAndTypeIndex;
	int classIndex;
	// Looking into the method ref table
	if ((index = wellKnownMethods[INVOKE_METHOD_METHOD]) == 0) {
		classIndex = literalIndexForJavaLangReflectMethod();
		if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[INVOKE_METHOD_METHOD_NAME_AND_TYPE]) == 0) {
			int nameIndex = literalIndex(INVOKE_METHOD_METHOD_NAME);
			int typeIndex = literalIndex(INVOKE_METHOD_METHOD_SIGNATURE);
			nameAndTypeIndex = wellKnownMethodNameAndTypes[INVOKE_METHOD_METHOD_NAME_AND_TYPE] = currentIndex++;
			writeU1(NameAndTypeTag);
			writeU2(nameIndex);
			writeU2(typeIndex);
		}
		index = wellKnownMethods[INVOKE_METHOD_METHOD] = currentIndex++;
		// Write the method ref constant into the constant pool
		// First add the tag
		writeU1(MethodRefTag);
		// Then write the class index
		writeU2(classIndex);
		// The write the nameAndType index
		writeU2(nameAndTypeIndex);
	}
	return index;
}
/**
 * This method returns the index into the constantPool corresponding to the 
 * method descriptor. It can be either an interface method reference constant
 * or a method reference constant.
 *
 * @return <CODE>int</CODE>
 */
public int literalIndexForJavaLangShortShortValue() {
	int index;
	int nameAndTypeIndex;
	int classIndex;
	// Looking into the method ref table
	if ((index = wellKnownMethods[SHORTVALUE_SHORT_METHOD]) == 0) {
		classIndex = literalIndexForJavaLangShort();
		if ((nameAndTypeIndex = wellKnownMethodNameAndTypes[SHORTVALUE_SHORT_METHOD_NAME_AND_TYPE]) == 0) {
			int nameIndex = literalIndex(SHORTVALUE_SHORT_METHOD_NAME);
			int typeIndex = literalIndex(SHORTVALUE_SHORT_METHOD_SIGNATURE);
			nameAndTypeIndex = wellKnownMethodNameAndTypes[SHORTVALUE_SHORT_METHOD_NAME_AND_TYPE] = currentIndex++;
			writeU1(NameAndTypeTag);
			writeU2(nameIndex);
			writeU2(typeIndex);
		}
		index = wellKnownMethods[SHORTVALUE_SHORT_METHOD] = currentIndex++;
		// Write the method ref constant into the constant pool
		// First add the tag
		writeU1(MethodRefTag);
		// Then write the class index
		writeU2(classIndex);
		// The write the nameAndType index
		writeU2(nameAndTypeIndex);
	}
	return index;
}
/**
 * This method returns the index into the constantPool corresponding 
 * nameAndType constant with nameIndex, typeIndex.
 *
 * @param int nameIndex
 * @param int nameIndex
 * @param org.eclipse.jdt.internal.compiler.lookup.MethodBinding a methodBinding
 * @return <CODE>int</CODE>
 */
public int literalIndexForMethods(int nameIndex, int typeIndex, MethodBinding key) {
	int index;
	int indexOfWellKnownMethodNameAndType;
	if ((indexOfWellKnownMethodNameAndType = super.indexOfWellKnownMethodNameAndType(key)) == -1) {
		if ((indexOfWellKnownMethodNameAndType = indexOfWellKnownMethodNameAndType(key)) == -1) {
			// check if the entry exists
			if ((index = nameAndTypeCacheForMethods.get(key)) == -1) {
				// The entry doesn't exit yet
				index = nameAndTypeCacheForMethods.put(key, currentIndex++);
				writeU1(NameAndTypeTag);
				writeU2(nameIndex);
				writeU2(typeIndex);
			}
		} else {
			if ((index = wellKnownMethodNameAndTypes[indexOfWellKnownMethodNameAndType]) == 0) {
				index = wellKnownMethodNameAndTypes[indexOfWellKnownMethodNameAndType] = currentIndex++;
				writeU1(NameAndTypeTag);
				writeU2(nameIndex);
				writeU2(typeIndex);
			}
		}
	} else {
		index = super.literalIndexForMethods(nameIndex,typeIndex,key);
	}
	return index;
}
/**
 * This method returns the index into the constantPool corresponding to the 
 * method descriptor. It can be either an interface method reference constant
 * or a method reference constant.
 *
 * @return <CODE>int</CODE>
 */
public int literalIndexJavaLangReflectFieldGetter(int typeID) {
	int index = 0;
	int nameAndTypeIndex = 0;
	int classIndex = 0;
	switch (typeID) {
		case T_int :
			if ((index = wellKnownMethods[GET_INT_METHOD]) == 0) {
				classIndex = literalIndexForJavaLangReflectField();
				if ((nameAndTypeIndex =
					wellKnownMethodNameAndTypes[GET_INT_METHOD_NAME_AND_TYPE])
					== 0) {
					int nameIndex = literalIndex(GET_INT_METHOD_NAME);
					int typeIndex = literalIndex(GET_INT_METHOD_SIGNATURE);
					nameAndTypeIndex =
						wellKnownMethodNameAndTypes[GET_INT_METHOD_NAME_AND_TYPE] = currentIndex++;
					writeU1(NameAndTypeTag);
					writeU2(nameIndex);
					writeU2(typeIndex);
				}
				index = wellKnownMethods[GET_INT_METHOD] = currentIndex++;
				// Write the method ref constant into the constant pool
				// First add the tag
				writeU1(MethodRefTag);
				// Then write the class index
				writeU2(classIndex);
				// The write the nameAndType index
				writeU2(nameAndTypeIndex);
			}
			break;
		case T_byte :
			if ((index = wellKnownMethods[GET_BYTE_METHOD]) == 0) {
				classIndex = literalIndexForJavaLangReflectField();
				if ((nameAndTypeIndex =
					wellKnownMethodNameAndTypes[GET_BYTE_METHOD_NAME_AND_TYPE])
					== 0) {
					int nameIndex = literalIndex(GET_BYTE_METHOD_NAME);
					int typeIndex = literalIndex(GET_BYTE_METHOD_SIGNATURE);
					nameAndTypeIndex =
						wellKnownMethodNameAndTypes[GET_BYTE_METHOD_NAME_AND_TYPE] = currentIndex++;
					writeU1(NameAndTypeTag);
					writeU2(nameIndex);
					writeU2(typeIndex);
				}
				index = wellKnownMethods[GET_BYTE_METHOD] = currentIndex++;
				// Write the method ref constant into the constant pool
				// First add the tag
				writeU1(MethodRefTag);
				// Then write the class index
				writeU2(classIndex);
				// The write the nameAndType index
				writeU2(nameAndTypeIndex);
			}
			break;
		case T_short :
			if ((index = wellKnownMethods[GET_SHORT_METHOD]) == 0) {
				classIndex = literalIndexForJavaLangReflectField();
				if ((nameAndTypeIndex =
					wellKnownMethodNameAndTypes[GET_SHORT_METHOD_NAME_AND_TYPE])
					== 0) {
					int nameIndex = literalIndex(GET_SHORT_METHOD_NAME);
					int typeIndex = literalIndex(GET_SHORT_METHOD_SIGNATURE);
					nameAndTypeIndex =
						wellKnownMethodNameAndTypes[GET_SHORT_METHOD_NAME_AND_TYPE] = currentIndex++;
					writeU1(NameAndTypeTag);
					writeU2(nameIndex);
					writeU2(typeIndex);
				}
				index = wellKnownMethods[GET_SHORT_METHOD] = currentIndex++;
				// Write the method ref constant into the constant pool
				// First add the tag
				writeU1(MethodRefTag);
				// Then write the class index
				writeU2(classIndex);
				// The write the nameAndType index
				writeU2(nameAndTypeIndex);
			}
			break;
		case T_long :
			if ((index = wellKnownMethods[GET_LONG_METHOD]) == 0) {
				classIndex = literalIndexForJavaLangReflectField();
				if ((nameAndTypeIndex =
					wellKnownMethodNameAndTypes[GET_LONG_METHOD_NAME_AND_TYPE])
					== 0) {
					int nameIndex = literalIndex(GET_LONG_METHOD_NAME);
					int typeIndex = literalIndex(GET_LONG_METHOD_SIGNATURE);
					nameAndTypeIndex =
						wellKnownMethodNameAndTypes[GET_LONG_METHOD_NAME_AND_TYPE] = currentIndex++;
					writeU1(NameAndTypeTag);
					writeU2(nameIndex);
					writeU2(typeIndex);
				}
				index = wellKnownMethods[GET_LONG_METHOD] = currentIndex++;
				// Write the method ref constant into the constant pool
				// First add the tag
				writeU1(MethodRefTag);
				// Then write the class index
				writeU2(classIndex);
				// The write the nameAndType index
				writeU2(nameAndTypeIndex);
			}
			break;
		case T_float :
			if ((index = wellKnownMethods[GET_FLOAT_METHOD]) == 0) {
				classIndex = literalIndexForJavaLangReflectField();
				if ((nameAndTypeIndex =
					wellKnownMethodNameAndTypes[GET_FLOAT_METHOD_NAME_AND_TYPE])
					== 0) {
					int nameIndex = literalIndex(GET_FLOAT_METHOD_NAME);
					int typeIndex = literalIndex(GET_FLOAT_METHOD_SIGNATURE);
					nameAndTypeIndex =
						wellKnownMethodNameAndTypes[GET_FLOAT_METHOD_NAME_AND_TYPE] = currentIndex++;
					writeU1(NameAndTypeTag);
					writeU2(nameIndex);
					writeU2(typeIndex);
				}
				index = wellKnownMethods[GET_FLOAT_METHOD] = currentIndex++;
				// Write the method ref constant into the constant pool
				// First add the tag
				writeU1(MethodRefTag);
				// Then write the class index
				writeU2(classIndex);
				// The write the nameAndType index
				writeU2(nameAndTypeIndex);
			}
			break;
		case T_double :
			if ((index = wellKnownMethods[GET_DOUBLE_METHOD]) == 0) {
				classIndex = literalIndexForJavaLangReflectField();
				if ((nameAndTypeIndex =
					wellKnownMethodNameAndTypes[GET_DOUBLE_METHOD_NAME_AND_TYPE])
					== 0) {
					int nameIndex = literalIndex(GET_DOUBLE_METHOD_NAME);
					int typeIndex = literalIndex(GET_DOUBLE_METHOD_SIGNATURE);
					nameAndTypeIndex =
						wellKnownMethodNameAndTypes[GET_DOUBLE_METHOD_NAME_AND_TYPE] =
							currentIndex++;
					writeU1(NameAndTypeTag);
					writeU2(nameIndex);
					writeU2(typeIndex);
				}
				index = wellKnownMethods[GET_DOUBLE_METHOD] = currentIndex++;
				// Write the method ref constant into the constant pool
				// First add the tag
				writeU1(MethodRefTag);
				// Then write the class index
				writeU2(classIndex);
				// The write the nameAndType index
				writeU2(nameAndTypeIndex);
			}
			break;
		case T_char :
			if ((index = wellKnownMethods[GET_CHAR_METHOD]) == 0) {
				classIndex = literalIndexForJavaLangReflectField();
				if ((nameAndTypeIndex =
					wellKnownMethodNameAndTypes[GET_CHAR_METHOD_NAME_AND_TYPE])
					== 0) {
					int nameIndex = literalIndex(GET_CHAR_METHOD_NAME);
					int typeIndex = literalIndex(GET_CHAR_METHOD_SIGNATURE);
					nameAndTypeIndex =
						wellKnownMethodNameAndTypes[GET_CHAR_METHOD_NAME_AND_TYPE] = currentIndex++;
					writeU1(NameAndTypeTag);
					writeU2(nameIndex);
					writeU2(typeIndex);
				}
				index = wellKnownMethods[GET_CHAR_METHOD] = currentIndex++;
				// Write the method ref constant into the constant pool
				// First add the tag
				writeU1(MethodRefTag);
				// Then write the class index
				writeU2(classIndex);
				// The write the nameAndType index
				writeU2(nameAndTypeIndex);
			}
			break;
		case T_boolean :
			if ((index = wellKnownMethods[GET_BOOLEAN_METHOD]) == 0) {
				classIndex = literalIndexForJavaLangReflectField();
				if ((nameAndTypeIndex =
					wellKnownMethodNameAndTypes[GET_BOOLEAN_METHOD_NAME_AND_TYPE])
					== 0) {
					int nameIndex = literalIndex(GET_BOOLEAN_METHOD_NAME);
					int typeIndex = literalIndex(GET_BOOLEAN_METHOD_SIGNATURE);
					nameAndTypeIndex =
						wellKnownMethodNameAndTypes[GET_BOOLEAN_METHOD_NAME_AND_TYPE] =
							currentIndex++;
					writeU1(NameAndTypeTag);
					writeU2(nameIndex);
					writeU2(typeIndex);
				}
				index = wellKnownMethods[GET_BOOLEAN_METHOD] = currentIndex++;
				// Write the method ref constant into the constant pool
				// First add the tag
				writeU1(MethodRefTag);
				// Then write the class index
				writeU2(classIndex);
				// The write the nameAndType index
				writeU2(nameAndTypeIndex);
			}
			break;
		default :
			if ((index = wellKnownMethods[GET_OBJECT_METHOD]) == 0) {
				classIndex = literalIndexForJavaLangReflectField();
				if ((nameAndTypeIndex =
					wellKnownMethodNameAndTypes[GET_OBJECT_METHOD_NAME_AND_TYPE])
					== 0) {
					int nameIndex = literalIndex(GET_OBJECT_METHOD_NAME);
					int typeIndex = literalIndex(GET_OBJECT_METHOD_SIGNATURE);
					nameAndTypeIndex =
						wellKnownMethodNameAndTypes[GET_OBJECT_METHOD_NAME_AND_TYPE] =
							currentIndex++;
					writeU1(NameAndTypeTag);
					writeU2(nameIndex);
					writeU2(typeIndex);
				}
				index = wellKnownMethods[GET_OBJECT_METHOD] = currentIndex++;
				// Write the method ref constant into the constant pool
				// First add the tag
				writeU1(MethodRefTag);
				// Then write the class index
				writeU2(classIndex);
				// The write the nameAndType index
				writeU2(nameAndTypeIndex);
			}
		}
	return index;
}
/**
 * This method returns the index into the constantPool corresponding to the 
 * method descriptor. It can be either an interface method reference constant
 * or a method reference constant.
 *
 * @return <CODE>int</CODE>
 */
public int literalIndexJavaLangReflectFieldSetter(int typeID) {
	int index = 0;
	int nameAndTypeIndex = 0;
	int classIndex = 0;
	switch (typeID) {
		case T_int :
			if ((index = wellKnownMethods[SET_INT_METHOD]) == 0) {
				classIndex = literalIndexForJavaLangReflectField();
				if ((nameAndTypeIndex =
					wellKnownMethodNameAndTypes[SET_INT_METHOD_NAME_AND_TYPE])
					== 0) {
					int nameIndex = literalIndex(SET_INT_METHOD_NAME);
					int typeIndex = literalIndex(SET_INT_METHOD_SIGNATURE);
					nameAndTypeIndex =
						wellKnownMethodNameAndTypes[SET_INT_METHOD_NAME_AND_TYPE] = currentIndex++;
					writeU1(NameAndTypeTag);
					writeU2(nameIndex);
					writeU2(typeIndex);
				}
				index = wellKnownMethods[SET_INT_METHOD] = currentIndex++;
				// Write the method ref constant into the constant pool
				// First add the tag
				writeU1(MethodRefTag);
				// Then write the class index
				writeU2(classIndex);
				// The write the nameAndType index
				writeU2(nameAndTypeIndex);
			}
			break;
		case T_byte :
			if ((index = wellKnownMethods[SET_BYTE_METHOD]) == 0) {
				classIndex = literalIndexForJavaLangReflectField();
				if ((nameAndTypeIndex =
					wellKnownMethodNameAndTypes[SET_BYTE_METHOD_NAME_AND_TYPE])
					== 0) {
					int nameIndex = literalIndex(SET_BYTE_METHOD_NAME);
					int typeIndex = literalIndex(SET_BYTE_METHOD_SIGNATURE);
					nameAndTypeIndex =
						wellKnownMethodNameAndTypes[SET_BYTE_METHOD_NAME_AND_TYPE] = currentIndex++;
					writeU1(NameAndTypeTag);
					writeU2(nameIndex);
					writeU2(typeIndex);
				}
				index = wellKnownMethods[SET_BYTE_METHOD] = currentIndex++;
				// Write the method ref constant into the constant pool
				// First add the tag
				writeU1(MethodRefTag);
				// Then write the class index
				writeU2(classIndex);
				// The write the nameAndType index
				writeU2(nameAndTypeIndex);
			}
			break;
		case T_short :
			if ((index = wellKnownMethods[SET_SHORT_METHOD]) == 0) {
				classIndex = literalIndexForJavaLangReflectField();
				if ((nameAndTypeIndex =
					wellKnownMethodNameAndTypes[SET_SHORT_METHOD_NAME_AND_TYPE])
					== 0) {
					int nameIndex = literalIndex(SET_SHORT_METHOD_NAME);
					int typeIndex = literalIndex(SET_SHORT_METHOD_SIGNATURE);
					nameAndTypeIndex =
						wellKnownMethodNameAndTypes[SET_SHORT_METHOD_NAME_AND_TYPE] = currentIndex++;
					writeU1(NameAndTypeTag);
					writeU2(nameIndex);
					writeU2(typeIndex);
				}
				index = wellKnownMethods[SET_SHORT_METHOD] = currentIndex++;
				// Write the method ref constant into the constant pool
				// First add the tag
				writeU1(MethodRefTag);
				// Then write the class index
				writeU2(classIndex);
				// The write the nameAndType index
				writeU2(nameAndTypeIndex);
			}
			break;
		case T_long :
			if ((index = wellKnownMethods[SET_LONG_METHOD]) == 0) {
				classIndex = literalIndexForJavaLangReflectField();
				if ((nameAndTypeIndex =
					wellKnownMethodNameAndTypes[SET_LONG_METHOD_NAME_AND_TYPE])
					== 0) {
					int nameIndex = literalIndex(SET_LONG_METHOD_NAME);
					int typeIndex = literalIndex(SET_LONG_METHOD_SIGNATURE);
					nameAndTypeIndex =
						wellKnownMethodNameAndTypes[SET_LONG_METHOD_NAME_AND_TYPE] = currentIndex++;
					writeU1(NameAndTypeTag);
					writeU2(nameIndex);
					writeU2(typeIndex);
				}
				index = wellKnownMethods[SET_LONG_METHOD] = currentIndex++;
				// Write the method ref constant into the constant pool
				// First add the tag
				writeU1(MethodRefTag);
				// Then write the class index
				writeU2(classIndex);
				// The write the nameAndType index
				writeU2(nameAndTypeIndex);
			}
			break;
		case T_float :
			if ((index = wellKnownMethods[SET_FLOAT_METHOD]) == 0) {
				classIndex = literalIndexForJavaLangReflectField();
				if ((nameAndTypeIndex =
					wellKnownMethodNameAndTypes[SET_FLOAT_METHOD_NAME_AND_TYPE])
					== 0) {
					int nameIndex = literalIndex(SET_FLOAT_METHOD_NAME);
					int typeIndex = literalIndex(SET_FLOAT_METHOD_SIGNATURE);
					nameAndTypeIndex =
						wellKnownMethodNameAndTypes[SET_FLOAT_METHOD_NAME_AND_TYPE] = currentIndex++;
					writeU1(NameAndTypeTag);
					writeU2(nameIndex);
					writeU2(typeIndex);
				}
				index = wellKnownMethods[SET_FLOAT_METHOD] = currentIndex++;
				// Write the method ref constant into the constant pool
				// First add the tag
				writeU1(MethodRefTag);
				// Then write the class index
				writeU2(classIndex);
				// The write the nameAndType index
				writeU2(nameAndTypeIndex);
			}
			break;
		case T_double :
			if ((index = wellKnownMethods[SET_DOUBLE_METHOD]) == 0) {
				classIndex = literalIndexForJavaLangReflectField();
				if ((nameAndTypeIndex =
					wellKnownMethodNameAndTypes[SET_DOUBLE_METHOD_NAME_AND_TYPE])
					== 0) {
					int nameIndex = literalIndex(SET_DOUBLE_METHOD_NAME);
					int typeIndex = literalIndex(SET_DOUBLE_METHOD_SIGNATURE);
					nameAndTypeIndex =
						wellKnownMethodNameAndTypes[SET_DOUBLE_METHOD_NAME_AND_TYPE] =
							currentIndex++;
					writeU1(NameAndTypeTag);
					writeU2(nameIndex);
					writeU2(typeIndex);
				}
				index = wellKnownMethods[SET_DOUBLE_METHOD] = currentIndex++;
				// Write the method ref constant into the constant pool
				// First add the tag
				writeU1(MethodRefTag);
				// Then write the class index
				writeU2(classIndex);
				// The write the nameAndType index
				writeU2(nameAndTypeIndex);
			}
			break;
		case T_char :
			if ((index = wellKnownMethods[SET_CHAR_METHOD]) == 0) {
				classIndex = literalIndexForJavaLangReflectField();
				if ((nameAndTypeIndex =
					wellKnownMethodNameAndTypes[SET_CHAR_METHOD_NAME_AND_TYPE])
					== 0) {
					int nameIndex = literalIndex(SET_CHAR_METHOD_NAME);
					int typeIndex = literalIndex(SET_CHAR_METHOD_SIGNATURE);
					nameAndTypeIndex =
						wellKnownMethodNameAndTypes[SET_CHAR_METHOD_NAME_AND_TYPE] = currentIndex++;
					writeU1(NameAndTypeTag);
					writeU2(nameIndex);
					writeU2(typeIndex);
				}
				index = wellKnownMethods[SET_CHAR_METHOD] = currentIndex++;
				// Write the method ref constant into the constant pool
				// First add the tag
				writeU1(MethodRefTag);
				// Then write the class index
				writeU2(classIndex);
				// The write the nameAndType index
				writeU2(nameAndTypeIndex);
			}
			break;
		case T_boolean :
			if ((index = wellKnownMethods[SET_BOOLEAN_METHOD]) == 0) {
				classIndex = literalIndexForJavaLangReflectField();
				if ((nameAndTypeIndex =
					wellKnownMethodNameAndTypes[SET_BOOLEAN_METHOD_NAME_AND_TYPE])
					== 0) {
					int nameIndex = literalIndex(SET_BOOLEAN_METHOD_NAME);
					int typeIndex = literalIndex(SET_BOOLEAN_METHOD_SIGNATURE);
					nameAndTypeIndex =
						wellKnownMethodNameAndTypes[SET_BOOLEAN_METHOD_NAME_AND_TYPE] =
							currentIndex++;
					writeU1(NameAndTypeTag);
					writeU2(nameIndex);
					writeU2(typeIndex);
				}
				index = wellKnownMethods[SET_BOOLEAN_METHOD] = currentIndex++;
				// Write the method ref constant into the constant pool
				// First add the tag
				writeU1(MethodRefTag);
				// Then write the class index
				writeU2(classIndex);
				// The write the nameAndType index
				writeU2(nameAndTypeIndex);
			}
			break;
		default :
			if ((index = wellKnownMethods[SET_OBJECT_METHOD]) == 0) {
				classIndex = literalIndexForJavaLangReflectField();
				if ((nameAndTypeIndex =
					wellKnownMethodNameAndTypes[SET_OBJECT_METHOD_NAME_AND_TYPE])
					== 0) {
					int nameIndex = literalIndex(SET_OBJECT_METHOD_NAME);
					int typeIndex = literalIndex(SET_OBJECT_METHOD_SIGNATURE);
					nameAndTypeIndex =
						wellKnownMethodNameAndTypes[SET_OBJECT_METHOD_NAME_AND_TYPE] =
							currentIndex++;
					writeU1(NameAndTypeTag);
					writeU2(nameIndex);
					writeU2(typeIndex);
				}
				index = wellKnownMethods[SET_OBJECT_METHOD] = currentIndex++;
				// Write the method ref constant into the constant pool
				// First add the tag
				writeU1(MethodRefTag);
				// Then write the class index
				writeU2(classIndex);
				// The write the nameAndType index
				writeU2(nameAndTypeIndex);
			}
		}
	return index;
}
}