62 private int slot;
63 // This is guaranteed to be interned by the VM in the 1.4
64 // reflection implementation
65 private String name;
66 private Class<?> type;
67 private int modifiers;
68 // Generics and annotations support
69 private transient String signature;
70 // generic info repository; lazily initialized
71 private transient FieldRepository genericInfo;
72 private byte[] annotations;
73 // Cached field accessor created without override
74 private FieldAccessor fieldAccessor;
75 // Cached field accessor created with override
76 private FieldAccessor overrideFieldAccessor;
77 // For sharing of FieldAccessors. This branching structure is
78 // currently only two levels deep (i.e., one root Field and
79 // potentially many Field objects pointing to it.)
80 private Field root;
81
82 // More complicated security check cache needed here than for
83 // Class.newInstance() and Constructor.newInstance()
84 private Class<?> securityCheckCache;
85 private Class<?> securityCheckTargetClassCache;
86
87 // Generics infrastructure
88
89 private String getGenericSignature() {return signature;}
90
91 // Accessor for factory
92 private GenericsFactory getFactory() {
93 Class<?> c = getDeclaringClass();
94 // create scope and factory
95 return CoreReflectionFactory.make(c, ClassScope.make(c));
96 }
97
98 // Accessor for generic info repository
99 private FieldRepository getGenericInfo() {
100 // lazily initialize repository if necessary
101 if (genericInfo == null) {
102 // create and cache generic info repository
103 genericInfo = FieldRepository.make(getGenericSignature(),
104 getFactory());
105 }
106 return genericInfo; //return cached repository
919
920 // NOTE that there is no synchronization used here. It is correct
921 // (though not efficient) to generate more than one FieldAccessor
922 // for a given Field. However, avoiding synchronization will
923 // probably make the implementation more scalable.
924 private FieldAccessor acquireFieldAccessor(boolean overrideFinalCheck) {
925 // First check to see if one has been created yet, and take it
926 // if so
927 FieldAccessor tmp = null;
928 if (root != null) tmp = root.getFieldAccessor(overrideFinalCheck);
929 if (tmp != null) {
930 if (overrideFinalCheck)
931 overrideFieldAccessor = tmp;
932 else
933 fieldAccessor = tmp;
934 } else {
935 // Otherwise fabricate one and propagate it up to the root
936 tmp = reflectionFactory.newFieldAccessor(this, overrideFinalCheck);
937 setFieldAccessor(tmp, overrideFinalCheck);
938 }
939 return tmp;
940 }
941
942 // Returns FieldAccessor for this Field object, not looking up
943 // the chain to the root
944 private FieldAccessor getFieldAccessor(boolean overrideFinalCheck) {
945 return (overrideFinalCheck)? overrideFieldAccessor : fieldAccessor;
946 }
947
948 // Sets the FieldAccessor for this Field object and
949 // (recursively) its root
950 private void setFieldAccessor(FieldAccessor accessor, boolean overrideFinalCheck) {
951 if (overrideFinalCheck)
952 overrideFieldAccessor = accessor;
953 else
954 fieldAccessor = accessor;
955 // Propagate up
956 if (root != null) {
957 root.setFieldAccessor(accessor, overrideFinalCheck);
958 }
959 }
960
961 // NOTE: be very careful if you change the stack depth of this
962 // routine. The depth of the "getCallerClass" call is hardwired so
963 // that the compiler can have an easier time if this gets inlined.
964 private void doSecurityCheck(Object obj) throws IllegalAccessException {
965 if (!override) {
966 if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
967 Class<?> caller = Reflection.getCallerClass(4);
968 Class<?> targetClass = ((obj == null || !Modifier.isProtected(modifiers))
969 ? clazz
970 : obj.getClass());
971
972 synchronized (this) {
973 if ((securityCheckCache == caller)
974 && (securityCheckTargetClassCache == targetClass)) {
975 return;
976 }
977 }
978 Reflection.ensureMemberAccess(caller, clazz, obj, modifiers);
979 synchronized (this) {
980 securityCheckCache = caller;
981 securityCheckTargetClassCache = targetClass;
982 }
983 }
984 }
985 }
986
987 /*
988 * Utility routine to paper over array type names
989 */
990 static String getTypeName(Class<?> type) {
991 if (type.isArray()) {
992 try {
993 Class<?> cl = type;
994 int dimensions = 0;
995 while (cl.isArray()) {
996 dimensions++;
997 cl = cl.getComponentType();
998 }
999 StringBuffer sb = new StringBuffer();
1000 sb.append(cl.getName());
1001 for (int i = 0; i < dimensions; i++) {
1002 sb.append("[]");
|
62 private int slot;
63 // This is guaranteed to be interned by the VM in the 1.4
64 // reflection implementation
65 private String name;
66 private Class<?> type;
67 private int modifiers;
68 // Generics and annotations support
69 private transient String signature;
70 // generic info repository; lazily initialized
71 private transient FieldRepository genericInfo;
72 private byte[] annotations;
73 // Cached field accessor created without override
74 private FieldAccessor fieldAccessor;
75 // Cached field accessor created with override
76 private FieldAccessor overrideFieldAccessor;
77 // For sharing of FieldAccessors. This branching structure is
78 // currently only two levels deep (i.e., one root Field and
79 // potentially many Field objects pointing to it.)
80 private Field root;
81
82 // Generics infrastructure
83
84 private String getGenericSignature() {return signature;}
85
86 // Accessor for factory
87 private GenericsFactory getFactory() {
88 Class<?> c = getDeclaringClass();
89 // create scope and factory
90 return CoreReflectionFactory.make(c, ClassScope.make(c));
91 }
92
93 // Accessor for generic info repository
94 private FieldRepository getGenericInfo() {
95 // lazily initialize repository if necessary
96 if (genericInfo == null) {
97 // create and cache generic info repository
98 genericInfo = FieldRepository.make(getGenericSignature(),
99 getFactory());
100 }
101 return genericInfo; //return cached repository
914
915 // NOTE that there is no synchronization used here. It is correct
916 // (though not efficient) to generate more than one FieldAccessor
917 // for a given Field. However, avoiding synchronization will
918 // probably make the implementation more scalable.
919 private FieldAccessor acquireFieldAccessor(boolean overrideFinalCheck) {
920 // First check to see if one has been created yet, and take it
921 // if so
922 FieldAccessor tmp = null;
923 if (root != null) tmp = root.getFieldAccessor(overrideFinalCheck);
924 if (tmp != null) {
925 if (overrideFinalCheck)
926 overrideFieldAccessor = tmp;
927 else
928 fieldAccessor = tmp;
929 } else {
930 // Otherwise fabricate one and propagate it up to the root
931 tmp = reflectionFactory.newFieldAccessor(this, overrideFinalCheck);
932 setFieldAccessor(tmp, overrideFinalCheck);
933 }
934
935 return tmp;
936 }
937
938 // Returns FieldAccessor for this Field object, not looking up
939 // the chain to the root
940 private FieldAccessor getFieldAccessor(boolean overrideFinalCheck) {
941 return (overrideFinalCheck)? overrideFieldAccessor : fieldAccessor;
942 }
943
944 // Sets the FieldAccessor for this Field object and
945 // (recursively) its root
946 private void setFieldAccessor(FieldAccessor accessor, boolean overrideFinalCheck) {
947 if (overrideFinalCheck)
948 overrideFieldAccessor = accessor;
949 else
950 fieldAccessor = accessor;
951 // Propagate up
952 if (root != null) {
953 root.setFieldAccessor(accessor, overrideFinalCheck);
954 }
955 }
956
957 // NOTE: be very careful if you change the stack depth of this
958 // routine. The depth of the "getCallerClass" call is hardwired so
959 // that the compiler can have an easier time if this gets inlined.
960 private void doSecurityCheck(Object obj) throws IllegalAccessException {
961 if (!override) {
962 if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
963 Class<?> caller = Reflection.getCallerClass(4);
964
965 checkAccess(caller, clazz, obj, modifiers);
966 }
967 }
968 }
969
970 /*
971 * Utility routine to paper over array type names
972 */
973 static String getTypeName(Class<?> type) {
974 if (type.isArray()) {
975 try {
976 Class<?> cl = type;
977 int dimensions = 0;
978 while (cl.isArray()) {
979 dimensions++;
980 cl = cl.getComponentType();
981 }
982 StringBuffer sb = new StringBuffer();
983 sb.append(cl.getName());
984 for (int i = 0; i < dimensions; i++) {
985 sb.append("[]");
|