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; | |
} | |
} |