| // natClass.cc - Implementation of java.lang.Class native methods. | |
| /* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 | |
| Free Software Foundation | |
| This file is part of libgcj. | |
| This software is copyrighted work licensed under the terms of the | |
| Libgcj License. Please consult the file "LIBGCJ_LICENSE" for | |
| details. */ | |
| #include <config.h> | |
| #include <limits.h> | |
| #include <string.h> | |
| #include <stddef.h> | |
| #include <stdio.h> | |
| #pragma implementation "Class.h" | |
| #include <gcj/cni.h> | |
| #include <jvm.h> | |
| #include <java-threads.h> | |
| #include <java/lang/Class.h> | |
| #include <java/lang/ClassLoader.h> | |
| #include <java/lang/String.h> | |
| #include <java/lang/reflect/Modifier.h> | |
| #include <java/lang/reflect/Member.h> | |
| #include <java/lang/reflect/Method.h> | |
| #include <java/lang/reflect/Field.h> | |
| #include <java/lang/reflect/Proxy.h> | |
| #include <java/lang/reflect/Constructor.h> | |
| #include <java/lang/AbstractMethodError.h> | |
| #include <java/lang/ArrayStoreException.h> | |
| #include <java/lang/ClassCastException.h> | |
| #include <java/lang/ClassNotFoundException.h> | |
| #include <java/lang/ExceptionInInitializerError.h> | |
| #include <java/lang/IllegalAccessException.h> | |
| #include <java/lang/IllegalAccessError.h> | |
| #include <java/lang/IllegalArgumentException.h> | |
| #include <java/lang/IncompatibleClassChangeError.h> | |
| #include <java/lang/NoSuchFieldError.h> | |
| #include <java/lang/ArrayIndexOutOfBoundsException.h> | |
| #include <java/lang/InstantiationException.h> | |
| #include <java/lang/NoClassDefFoundError.h> | |
| #include <java/lang/NoSuchFieldException.h> | |
| #include <java/lang/NoSuchMethodError.h> | |
| #include <java/lang/NoSuchMethodException.h> | |
| #include <java/lang/Thread.h> | |
| #include <java/lang/NullPointerException.h> | |
| #include <java/lang/RuntimePermission.h> | |
| #include <java/lang/System.h> | |
| #include <java/lang/SecurityException.h> | |
| #include <java/lang/SecurityManager.h> | |
| #include <java/lang/StringBuffer.h> | |
| #include <java/lang/VMClassLoader.h> | |
| #include <gcj/method.h> | |
| #include <gnu/gcj/RawData.h> | |
| #include <java/lang/VerifyError.h> | |
| #include <java/lang/InternalError.h> | |
| #include <java/lang/TypeNotPresentException.h> | |
| #include <java/lang/Byte.h> | |
| #include <java/lang/Short.h> | |
| #include <java/lang/Integer.h> | |
| #include <java/lang/Float.h> | |
| #include <java/lang/Double.h> | |
| #include <java/lang/Long.h> | |
| #include <java/lang/Character.h> | |
| #include <java/lang/Boolean.h> | |
| #include <java/lang/annotation/Annotation.h> | |
| #include <java/util/HashMap.h> | |
| #include <java/util/Map.h> | |
| #include <sun/reflect/annotation/AnnotationInvocationHandler.h> | |
| #include <java/lang/Enum.h> | |
| #include <java-cpool.h> | |
| #include <java-interp.h> | |
| #include <java-assert.h> | |
| #include <java-stack.h> | |
| #include <execution.h> | |
| using namespace gcj; | |
| jclass | |
| java::lang::Class::forName (jstring className, jboolean initialize, | |
| java::lang::ClassLoader *loader) | |
| { | |
| if (! className) | |
| throw new java::lang::NullPointerException; | |
| jsize length = _Jv_GetStringUTFLength (className); | |
| char buffer[length]; | |
| _Jv_GetStringUTFRegion (className, 0, className->length(), buffer); | |
| _Jv_Utf8Const *name = _Jv_makeUtf8Const (buffer, length); | |
| if (! _Jv_VerifyClassName (name)) | |
| throw new java::lang::ClassNotFoundException (className); | |
| jclass klass = (buffer[0] == '[' | |
| ? _Jv_FindClassFromSignature (name->chars(), loader) | |
| : _Jv_FindClass (name, loader)); | |
| if (klass == NULL) | |
| throw new java::lang::ClassNotFoundException (className); | |
| if (initialize) | |
| _Jv_InitClass (klass); | |
| return klass; | |
| } | |
| jclass | |
| java::lang::Class::forName (jstring className) | |
| { | |
| java::lang::ClassLoader *loader = NULL; | |
| jclass caller = _Jv_StackTrace::GetCallingClass (&Class::class$); | |
| if (caller) | |
| loader = caller->getClassLoaderInternal(); | |
| return forName (className, true, loader); | |
| } | |
| java::lang::ClassLoader * | |
| java::lang::Class::getClassLoader (void) | |
| { | |
| java::lang::SecurityManager *s = java::lang::System::getSecurityManager(); | |
| if (s != NULL) | |
| { | |
| jclass caller = _Jv_StackTrace::GetCallingClass (&Class::class$); | |
| return getClassLoader (caller); | |
| } | |
| return loader; | |
| } | |
| java::lang::ClassLoader * | |
| java::lang::Class::getClassLoader (jclass caller) | |
| { | |
| java::lang::SecurityManager *s = java::lang::System::getSecurityManager(); | |
| if (s != NULL) | |
| { | |
| ClassLoader *caller_loader = caller->getClassLoaderInternal(); | |
| // If the caller has a non-null class loader, and that loader | |
| // is not this class' loader or an ancestor thereof, then do a | |
| // security check. | |
| if (caller_loader != NULL && ! caller_loader->isAncestorOf(loader)) | |
| s->checkPermission (new RuntimePermission (JvNewStringLatin1 ("getClassLoader"))); | |
| } | |
| return loader; | |
| } | |
| java::lang::reflect::Constructor * | |
| java::lang::Class::getConstructor (JArray<jclass> *param_types) | |
| { | |
| memberAccessCheck(java::lang::reflect::Member::PUBLIC); | |
| jstring partial_sig = getSignature (param_types, true); | |
| jint hash = partial_sig->hashCode (); | |
| int i = isPrimitive () ? 0 : method_count; | |
| while (--i >= 0) | |
| { | |
| if (_Jv_equalUtf8Consts (methods[i].name, init_name) | |
| && _Jv_equal (methods[i].signature, partial_sig, hash)) | |
| { | |
| // Found it. For getConstructor, the constructor must be | |
| // public. | |
| using namespace java::lang::reflect; | |
| if (! Modifier::isPublic(methods[i].accflags)) | |
| break; | |
| Constructor *cons = new Constructor (); | |
| cons->offset = (char *) (&methods[i]) - (char *) methods; | |
| cons->declaringClass = this; | |
| return cons; | |
| } | |
| } | |
| throw new java::lang::NoSuchMethodException (_Jv_NewStringUtf8Const (init_name)); | |
| } | |
| JArray<java::lang::reflect::Constructor *> * | |
| java::lang::Class::getDeclaredConstructors (jboolean publicOnly) | |
| { | |
| int numConstructors = 0; | |
| int max = isPrimitive () ? 0 : method_count; | |
| int i; | |
| for (i = max; --i >= 0; ) | |
| { | |
| _Jv_Method *method = &methods[i]; | |
| if (method->name == NULL | |
| || ! _Jv_equalUtf8Consts (method->name, init_name)) | |
| continue; | |
| if (publicOnly | |
| && ! java::lang::reflect::Modifier::isPublic(method->accflags)) | |
| continue; | |
| numConstructors++; | |
| } | |
| JArray<java::lang::reflect::Constructor *> *result | |
| = (JArray<java::lang::reflect::Constructor *> *) | |
| JvNewObjectArray (numConstructors, | |
| &java::lang::reflect::Constructor::class$, | |
| NULL); | |
| java::lang::reflect::Constructor** cptr = elements (result); | |
| for (i = 0; i < max; i++) | |
| { | |
| _Jv_Method *method = &methods[i]; | |
| if (method->name == NULL | |
| || ! _Jv_equalUtf8Consts (method->name, init_name)) | |
| continue; | |
| if (publicOnly | |
| && ! java::lang::reflect::Modifier::isPublic(method->accflags)) | |
| continue; | |
| java::lang::reflect::Constructor *cons | |
| = new java::lang::reflect::Constructor (); | |
| cons->offset = (char *) method - (char *) methods; | |
| cons->declaringClass = this; | |
| *cptr++ = cons; | |
| } | |
| return result; | |
| } | |
| java::lang::reflect::Constructor * | |
| java::lang::Class::getDeclaredConstructor (JArray<jclass> *param_types) | |
| { | |
| memberAccessCheck(java::lang::reflect::Member::DECLARED); | |
| jstring partial_sig = getSignature (param_types, true); | |
| jint hash = partial_sig->hashCode (); | |
| int i = isPrimitive () ? 0 : method_count; | |
| while (--i >= 0) | |
| { | |
| if (_Jv_equalUtf8Consts (methods[i].name, init_name) | |
| && _Jv_equal (methods[i].signature, partial_sig, hash)) | |
| { | |
| // Found it. | |
| using namespace java::lang::reflect; | |
| Constructor *cons = new Constructor (); | |
| cons->offset = (char *) (&methods[i]) - (char *) methods; | |
| cons->declaringClass = this; | |
| return cons; | |
| } | |
| } | |
| throw new java::lang::NoSuchMethodException (_Jv_NewStringUtf8Const (init_name)); | |
| } | |
| java::lang::reflect::Field * | |
| java::lang::Class::getField (jstring name, jint hash) | |
| { | |
| java::lang::reflect::Field* rfield; | |
| for (int i = 0; i < field_count; i++) | |
| { | |
| _Jv_Field *field = &fields[i]; | |
| if (! _Jv_equal (field->name, name, hash)) | |
| continue; | |
| if (! (field->getModifiers() & java::lang::reflect::Modifier::PUBLIC)) | |
| continue; | |
| rfield = new java::lang::reflect::Field (); | |
| rfield->offset = (char*) field - (char*) fields; | |
| rfield->declaringClass = this; | |
| rfield->name = name; | |
| return rfield; | |
| } | |
| jclass superclass = getSuperclass(); | |
| if (superclass == NULL) | |
| return NULL; | |
| rfield = superclass->getField(name, hash); | |
| for (int i = 0; i < interface_count && rfield == NULL; ++i) | |
| rfield = interfaces[i]->getField (name, hash); | |
| return rfield; | |
| } | |
| java::lang::reflect::Field * | |
| java::lang::Class::getDeclaredField (jstring name) | |
| { | |
| memberAccessCheck(java::lang::reflect::Member::DECLARED); | |
| int hash = name->hashCode(); | |
| for (int i = 0; i < field_count; i++) | |
| { | |
| _Jv_Field *field = &fields[i]; | |
| if (! _Jv_equal (field->name, name, hash)) | |
| continue; | |
| java::lang::reflect::Field* rfield = new java::lang::reflect::Field (); | |
| rfield->offset = (char*) field - (char*) fields; | |
| rfield->declaringClass = this; | |
| rfield->name = name; | |
| return rfield; | |
| } | |
| throw new java::lang::NoSuchFieldException (name); | |
| } | |
| JArray<java::lang::reflect::Field *> * | |
| java::lang::Class::getDeclaredFields (jboolean public_only) | |
| { | |
| int size; | |
| if (public_only) | |
| { | |
| size = 0; | |
| for (int i = 0; i < field_count; ++i) | |
| { | |
| _Jv_Field *field = &fields[i]; | |
| if ((field->flags & java::lang::reflect::Modifier::PUBLIC)) | |
| ++size; | |
| } | |
| } | |
| else | |
| size = field_count; | |
| JArray<java::lang::reflect::Field *> *result | |
| = (JArray<java::lang::reflect::Field *> *) | |
| JvNewObjectArray (size, &java::lang::reflect::Field::class$, NULL); | |
| java::lang::reflect::Field** fptr = elements (result); | |
| for (int i = 0; i < field_count; i++) | |
| { | |
| _Jv_Field *field = &fields[i]; | |
| if (public_only | |
| && ! (field->flags & java::lang::reflect::Modifier::PUBLIC)) | |
| continue; | |
| java::lang::reflect::Field* rfield = new java::lang::reflect::Field (); | |
| rfield->offset = (char*) field - (char*) fields; | |
| rfield->declaringClass = this; | |
| *fptr++ = rfield; | |
| } | |
| return result; | |
| } | |
| void | |
| java::lang::Class::getSignature (java::lang::StringBuffer *buffer) | |
| { | |
| if (isPrimitive()) | |
| buffer->append((jchar) method_count); | |
| else | |
| { | |
| jstring name = getName(); | |
| if (name->charAt(0) != '[') | |
| buffer->append((jchar) 'L'); | |
| buffer->append(name); | |
| if (name->charAt(0) != '[') | |
| buffer->append((jchar) ';'); | |
| } | |
| } | |
| // This doesn't have to be native. It is an implementation detail | |
| // only called from the C++ code, though, so maybe this is clearer. | |
| jstring | |
| java::lang::Class::getSignature (JArray<jclass> *param_types, | |
| jboolean is_constructor) | |
| { | |
| java::lang::StringBuffer *buf = new java::lang::StringBuffer (); | |
| buf->append((jchar) '('); | |
| // A NULL param_types means "no parameters". | |
| if (param_types != NULL) | |
| { | |
| jclass *v = elements (param_types); | |
| for (int i = 0; i < param_types->length; ++i) | |
| v[i]->getSignature(buf); | |
| } | |
| buf->append((jchar) ')'); | |
| if (is_constructor) | |
| buf->append((jchar) 'V'); | |
| return buf->toString(); | |
| } | |
| java::lang::reflect::Method * | |
| java::lang::Class::_getDeclaredMethod (jstring name, | |
| JArray<jclass> *param_types) | |
| { | |
| jstring partial_sig = getSignature (param_types, false); | |
| jint p_len = partial_sig->length(); | |
| _Jv_Utf8Const *utf_name = _Jv_makeUtf8Const (name); | |
| int i = isPrimitive () ? 0 : method_count; | |
| while (--i >= 0) | |
| { | |
| if (_Jv_equalUtf8Consts (methods[i].name, utf_name) | |
| && _Jv_equaln (methods[i].signature, partial_sig, p_len) | |
| && (methods[i].accflags | |
| & java::lang::reflect::Modifier::INVISIBLE) == 0) | |
| { | |
| // Found it. | |
| using namespace java::lang::reflect; | |
| Method *rmethod = new Method (); | |
| rmethod->offset = (char*) (&methods[i]) - (char*) methods; | |
| rmethod->declaringClass = this; | |
| return rmethod; | |
| } | |
| } | |
| return NULL; | |
| } | |
| JArray<java::lang::reflect::Method *> * | |
| java::lang::Class::getDeclaredMethods (void) | |
| { | |
| memberAccessCheck(java::lang::reflect::Member::DECLARED); | |
| int numMethods = 0; | |
| int max = isPrimitive () ? 0 : method_count; | |
| int i; | |
| for (i = max; --i >= 0; ) | |
| { | |
| _Jv_Method *method = &methods[i]; | |
| if (method->name == NULL | |
| || _Jv_equalUtf8Consts (method->name, clinit_name) | |
| || _Jv_equalUtf8Consts (method->name, init_name) | |
| || _Jv_equalUtf8Consts (method->name, finit_name) | |
| || (methods[i].accflags | |
| & java::lang::reflect::Modifier::INVISIBLE) != 0) | |
| continue; | |
| numMethods++; | |
| } | |
| JArray<java::lang::reflect::Method *> *result | |
| = (JArray<java::lang::reflect::Method *> *) | |
| JvNewObjectArray (numMethods, &java::lang::reflect::Method::class$, NULL); | |
| java::lang::reflect::Method** mptr = elements (result); | |
| for (i = 0; i < max; i++) | |
| { | |
| _Jv_Method *method = &methods[i]; | |
| if (method->name == NULL | |
| || _Jv_equalUtf8Consts (method->name, clinit_name) | |
| || _Jv_equalUtf8Consts (method->name, init_name) | |
| || _Jv_equalUtf8Consts (method->name, finit_name) | |
| || (methods[i].accflags | |
| & java::lang::reflect::Modifier::INVISIBLE) != 0) | |
| continue; | |
| java::lang::reflect::Method* rmethod | |
| = new java::lang::reflect::Method (); | |
| rmethod->offset = (char*) method - (char*) methods; | |
| rmethod->declaringClass = this; | |
| *mptr++ = rmethod; | |
| } | |
| return result; | |
| } | |
| jstring | |
| java::lang::Class::getName (void) | |
| { | |
| return name->toString(); | |
| } | |
| JArray<jclass> * | |
| java::lang::Class::getInterfaces (void) | |
| { | |
| jobjectArray r = JvNewObjectArray (interface_count, getClass (), NULL); | |
| jobject *data = elements (r); | |
| for (int i = 0; i < interface_count; ++i) | |
| { | |
| typedef unsigned int uaddr __attribute__ ((mode (pointer))); | |
| data[i] = interfaces[i]; | |
| if ((uaddr)data[i] < (uaddr)constants.size) | |
| fprintf (stderr, "ERROR !!!\n"); | |
| } | |
| return reinterpret_cast<JArray<jclass> *> (r); | |
| } | |
| java::lang::reflect::Method * | |
| java::lang::Class::_getMethod (jstring name, JArray<jclass> *param_types) | |
| { | |
| jstring partial_sig = getSignature (param_types, false); | |
| jint p_len = partial_sig->length(); | |
| _Jv_Utf8Const *utf_name = _Jv_makeUtf8Const (name); | |
| for (Class *klass = this; klass; klass = klass->getSuperclass()) | |
| { | |
| int i = klass->isPrimitive () ? 0 : klass->method_count; | |
| while (--i >= 0) | |
| { | |
| if (_Jv_equalUtf8Consts (klass->methods[i].name, utf_name) | |
| && _Jv_equaln (klass->methods[i].signature, partial_sig, p_len) | |
| && (klass->methods[i].accflags | |
| & java::lang::reflect::Modifier::INVISIBLE) == 0) | |
| { | |
| // Found it. | |
| using namespace java::lang::reflect; | |
| // Method must be public. | |
| if (! Modifier::isPublic (klass->methods[i].accflags)) | |
| break; | |
| Method *rmethod = new Method (); | |
| rmethod->offset = ((char *) (&klass->methods[i]) | |
| - (char *) klass->methods); | |
| rmethod->declaringClass = klass; | |
| return rmethod; | |
| } | |
| } | |
| } | |
| // If we haven't found a match, and this class is an interface, then | |
| // check all the superinterfaces. | |
| if (isInterface()) | |
| { | |
| for (int i = 0; i < interface_count; ++i) | |
| { | |
| using namespace java::lang::reflect; | |
| Method *rmethod = interfaces[i]->_getMethod (name, param_types); | |
| if (rmethod != NULL) | |
| return rmethod; | |
| } | |
| } | |
| return NULL; | |
| } | |
| // This is a very slow implementation, since it re-scans all the | |
| // methods we've already listed to make sure we haven't duplicated a | |
| // method. It also over-estimates the required size, so we have to | |
| // shrink the result array later. | |
| jint | |
| java::lang::Class::_getMethods (JArray<java::lang::reflect::Method *> *result, | |
| jint offset) | |
| { | |
| jint count = 0; | |
| // First examine all local methods | |
| for (int i = isPrimitive () ? 0 : method_count; --i >= 0; ) | |
| { | |
| _Jv_Method *method = &methods[i]; | |
| if (method->name == NULL | |
| || _Jv_equalUtf8Consts (method->name, clinit_name) | |
| || _Jv_equalUtf8Consts (method->name, init_name) | |
| || _Jv_equalUtf8Consts (method->name, finit_name) | |
| || (method->accflags | |
| & java::lang::reflect::Modifier::INVISIBLE) != 0) | |
| continue; | |
| // Only want public methods. | |
| if (! java::lang::reflect::Modifier::isPublic (method->accflags)) | |
| continue; | |
| // This is where we over-count the slots required if we aren't | |
| // filling the result for real. | |
| if (result != NULL) | |
| { | |
| jboolean add = true; | |
| java::lang::reflect::Method **mp = elements (result); | |
| // If we already have a method with this name and signature, | |
| // then ignore this one. This can happen with virtual | |
| // methods. | |
| for (int j = 0; j < offset; ++j) | |
| { | |
| _Jv_Method *meth_2 = _Jv_FromReflectedMethod (mp[j]); | |
| if (_Jv_equalUtf8Consts (method->name, meth_2->name) | |
| && _Jv_equalUtf8Consts (method->signature, | |
| meth_2->signature)) | |
| { | |
| add = false; | |
| break; | |
| } | |
| } | |
| if (! add) | |
| continue; | |
| } | |
| if (result != NULL) | |
| { | |
| using namespace java::lang::reflect; | |
| Method *rmethod = new Method (); | |
| rmethod->offset = (char *) method - (char *) methods; | |
| rmethod->declaringClass = this; | |
| Method **mp = elements (result); | |
| mp[offset + count] = rmethod; | |
| } | |
| ++count; | |
| } | |
| offset += count; | |
| // Now examine superclasses. | |
| if (getSuperclass () != NULL) | |
| { | |
| jint s_count = getSuperclass()->_getMethods (result, offset); | |
| offset += s_count; | |
| count += s_count; | |
| } | |
| // Finally, examine interfaces. | |
| for (int i = 0; i < interface_count; ++i) | |
| { | |
| int f_count = interfaces[i]->_getMethods (result, offset); | |
| count += f_count; | |
| offset += f_count; | |
| } | |
| return count; | |
| } | |
| JArray<java::lang::reflect::Method *> * | |
| java::lang::Class::getMethods (void) | |
| { | |
| using namespace java::lang::reflect; | |
| memberAccessCheck(Member::PUBLIC); | |
| // This will overestimate the size we need. | |
| jint count = _getMethods (NULL, 0); | |
| JArray<Method *> *result | |
| = ((JArray<Method *> *) JvNewObjectArray (count, | |
| &Method::class$, | |
| NULL)); | |
| // When filling the array for real, we get the actual count. Then | |
| // we resize the array. | |
| jint real_count = _getMethods (result, 0); | |
| if (real_count != count) | |
| { | |
| JArray<Method *> *r2 | |
| = ((JArray<Method *> *) JvNewObjectArray (real_count, | |
| &Method::class$, | |
| NULL)); | |
| Method **destp = elements (r2); | |
| Method **srcp = elements (result); | |
| for (int i = 0; i < real_count; ++i) | |
| *destp++ = *srcp++; | |
| result = r2; | |
| } | |
| return result; | |
| } | |
| jboolean | |
| java::lang::Class::isAssignableFrom (jclass klass) | |
| { | |
| // Arguments may not have been initialized, given ".class" syntax. | |
| // This ensures we can at least look at their superclasses. | |
| _Jv_Linker::wait_for_state (this, JV_STATE_LOADING); | |
| _Jv_Linker::wait_for_state (klass, JV_STATE_LOADING); | |
| return _Jv_IsAssignableFrom (klass, this); | |
| } | |
| jboolean | |
| java::lang::Class::isInstance (jobject obj) | |
| { | |
| if (! obj) | |
| return false; | |
| return _Jv_IsAssignableFrom (JV_CLASS (obj), this); | |
| } | |
| jobject | |
| java::lang::Class::newInstance (void) | |
| { | |
| memberAccessCheck(java::lang::reflect::Member::PUBLIC); | |
| if (isPrimitive () | |
| || isInterface () | |
| || isArray () | |
| || java::lang::reflect::Modifier::isAbstract(accflags)) | |
| throw new java::lang::InstantiationException (getName ()); | |
| _Jv_InitClass (this); | |
| _Jv_Method *meth = _Jv_GetMethodLocal (this, init_name, void_signature); | |
| if (! meth) | |
| throw new java::lang::InstantiationException (getName()); | |
| jobject r = _Jv_AllocObject (this); | |
| ((void (*) (jobject)) meth->ncode) (r); | |
| return r; | |
| } | |
| void | |
| java::lang::Class::finalize (void) | |
| { | |
| engine->unregister(this); | |
| } | |
| #ifdef INTERPRETER | |
| void | |
| _Jv_ClosureList::releaseClosures (_Jv_ClosureList **closures) | |
| { | |
| if (!closures) | |
| return; | |
| while (_Jv_ClosureList *current = *closures) | |
| { | |
| *closures = current->next; | |
| ffi_closure_free (current->ptr); | |
| } | |
| } | |
| void | |
| _Jv_ClosureList::registerClosure (jclass klass, void *ptr) | |
| { | |
| _Jv_ClosureList **closures = klass->engine->get_closure_list (klass); | |
| this->ptr = ptr; | |
| this->next = *closures; | |
| *closures = this; | |
| } | |
| #endif | |
| // This implements the initialization process for a class. From Spec | |
| // section 12.4.2. | |
| void | |
| java::lang::Class::initializeClass (void) | |
| { | |
| // Short-circuit to avoid needless locking (expression includes | |
| // JV_STATE_PHANTOM and JV_STATE_DONE). | |
| if (state >= JV_STATE_PHANTOM) | |
| return; | |
| // Step 1. We introduce a new scope so we can synchronize more | |
| // easily. | |
| { | |
| JvSynchronize sync (this); | |
| if (state < JV_STATE_LINKED) | |
| { | |
| try | |
| { | |
| _Jv_Linker::wait_for_state(this, JV_STATE_LINKED); | |
| } | |
| catch (java::lang::SecurityException *x) | |
| { | |
| throw x; | |
| } | |
| catch (java::lang::Throwable *x) | |
| { | |
| // Turn into a NoClassDefFoundError. | |
| java::lang::NoClassDefFoundError *result | |
| = new java::lang::NoClassDefFoundError(getName()); | |
| result->initCause(x); | |
| throw result; | |
| } | |
| } | |
| // Step 2. | |
| java::lang::Thread *self = java::lang::Thread::currentThread(); | |
| self = (java::lang::Thread *) ((long) self | 1); | |
| while (state == JV_STATE_IN_PROGRESS && thread && thread != self) | |
| wait (); | |
| // Steps 3 & 4. | |
| if (state == JV_STATE_DONE || state == JV_STATE_IN_PROGRESS) | |
| return; | |
| // Step 5. | |
| if (state == JV_STATE_ERROR) | |
| throw new java::lang::NoClassDefFoundError (getName()); | |
| // Step 6. | |
| thread = self; | |
| _Jv_Linker::wait_for_state (this, JV_STATE_LINKED); | |
| state = JV_STATE_IN_PROGRESS; | |
| } | |
| // Step 7. | |
| if (! isInterface () && superclass) | |
| { | |
| try | |
| { | |
| _Jv_InitClass (superclass); | |
| } | |
| catch (java::lang::SecurityException *x) | |
| { | |
| throw x; | |
| } | |
| catch (java::lang::Throwable *except) | |
| { | |
| // Caught an exception. | |
| JvSynchronize sync (this); | |
| state = JV_STATE_ERROR; | |
| notifyAll (); | |
| throw except; | |
| } | |
| } | |
| // Steps 8, 9, 10, 11. | |
| try | |
| { | |
| _Jv_Method *meth = _Jv_GetMethodLocal (this, clinit_name, | |
| void_signature); | |
| if (meth) | |
| ((void (*) (void)) meth->ncode) (); | |
| } | |
| catch (java::lang::SecurityException *x) | |
| { | |
| throw x; | |
| } | |
| catch (java::lang::Throwable *except) | |
| { | |
| if (! java::lang::Error::class$.isInstance(except)) | |
| { | |
| try | |
| { | |
| except = new ExceptionInInitializerError (except); | |
| } | |
| catch (java::lang::Throwable *t) | |
| { | |
| except = t; | |
| } | |
| } | |
| JvSynchronize sync (this); | |
| state = JV_STATE_ERROR; | |
| notifyAll (); | |
| throw except; | |
| } | |
| JvSynchronize sync (this); | |
| state = JV_STATE_DONE; | |
| notifyAll (); | |
| } | |
| // Only used by serialization | |
| java::lang::reflect::Field * | |
| java::lang::Class::getPrivateField (jstring name) | |
| { | |
| int hash = name->hashCode (); | |
| java::lang::reflect::Field* rfield; | |
| for (int i = 0; i < field_count; i++) | |
| { | |
| _Jv_Field *field = &fields[i]; | |
| if (! _Jv_equal (field->name, name, hash)) | |
| continue; | |
| rfield = new java::lang::reflect::Field (); | |
| rfield->offset = (char*) field - (char*) fields; | |
| rfield->declaringClass = this; | |
| rfield->name = name; | |
| return rfield; | |
| } | |
| jclass superclass = getSuperclass(); | |
| if (superclass == NULL) | |
| return NULL; | |
| rfield = superclass->getPrivateField(name); | |
| for (int i = 0; i < interface_count && rfield == NULL; ++i) | |
| rfield = interfaces[i]->getPrivateField (name); | |
| return rfield; | |
| } | |
| // Only used by serialization | |
| java::lang::reflect::Method * | |
| java::lang::Class::getPrivateMethod (jstring name, JArray<jclass> *param_types) | |
| { | |
| jstring partial_sig = getSignature (param_types, false); | |
| jint p_len = partial_sig->length(); | |
| _Jv_Utf8Const *utf_name = _Jv_makeUtf8Const (name); | |
| for (Class *klass = this; klass; klass = klass->getSuperclass()) | |
| { | |
| int i = klass->isPrimitive () ? 0 : klass->method_count; | |
| while (--i >= 0) | |
| { | |
| if (_Jv_equalUtf8Consts (klass->methods[i].name, utf_name) | |
| && _Jv_equaln (klass->methods[i].signature, partial_sig, p_len)) | |
| { | |
| // Found it. | |
| using namespace java::lang::reflect; | |
| Method *rmethod = new Method (); | |
| rmethod->offset = ((char *) (&klass->methods[i]) | |
| - (char *) klass->methods); | |
| rmethod->declaringClass = klass; | |
| return rmethod; | |
| } | |
| } | |
| } | |
| throw new java::lang::NoSuchMethodException (name); | |
| } | |
| // Private accessor method for Java code to retrieve the protection domain. | |
| java::security::ProtectionDomain * | |
| java::lang::Class::getProtectionDomain0 () | |
| { | |
| return protectionDomain; | |
| } | |
| JArray<jobject> * | |
| java::lang::Class::getSigners() | |
| { | |
| return hack_signers; | |
| } | |
| void | |
| java::lang::Class::setSigners(JArray<jobject> *s) | |
| { | |
| hack_signers = s; | |
| } | |
| static unsigned char | |
| read_u1 (unsigned char *&p) | |
| { | |
| return *p++; | |
| } | |
| static unsigned char | |
| read_u1 (unsigned char *&p, unsigned char *next) | |
| { | |
| if (next - p < 1) | |
| throw new java::lang::InternalError(); | |
| return *p++; | |
| } | |
| static unsigned int | |
| read_u2 (unsigned char *&p) | |
| { | |
| unsigned int b1 = *p++; | |
| unsigned int b2 = *p++; | |
| return (b1 << 8) | b2; | |
| } | |
| static unsigned int | |
| read_u2 (unsigned char *&p, unsigned char *next) | |
| { | |
| if (next - p < 2) | |
| throw new java::lang::InternalError(); | |
| return read_u2 (p); | |
| } | |
| static int | |
| read_4 (unsigned char *&p) | |
| { | |
| int b1 = *p++; | |
| int b2 = *p++; | |
| int b3 = *p++; | |
| int b4 = *p++; | |
| return (b1 << 24) | (b2 << 16) | (b3 << 8) | b4; | |
| } | |
| jstring | |
| java::lang::Class::getReflectionSignature (jint /*jv_attr_type*/ type, | |
| jint obj_index) | |
| { | |
| // We just re-parse the bytecode for this data each time. If | |
| // necessary we can cache results, but I suspect this is not | |
| // performance sensitive. | |
| unsigned char *bytes = reflection_data; | |
| if (bytes == NULL) | |
| return NULL; | |
| while (true) | |
| { | |
| int kind = read_u1 (bytes); | |
| if (kind == JV_DONE_ATTR) | |
| return NULL; | |
| int len = read_4 (bytes); | |
| unsigned char *next = bytes + len; | |
| if (kind != type) | |
| { | |
| bytes = next; | |
| continue; | |
| } | |
| if (type != JV_CLASS_ATTR) | |
| { | |
| unsigned short index = read_u2 (bytes, next); | |
| if (index != obj_index) | |
| { | |
| bytes = next; | |
| continue; | |
| } | |
| } | |
| int nt = read_u1 (bytes, next); | |
| if (nt != JV_SIGNATURE_KIND) | |
| { | |
| bytes = next; | |
| continue; | |
| } | |
| unsigned int cpool_idx = read_u2 (bytes, next); | |
| if (cpool_idx >= (unsigned int) constants.size | |
| || constants.tags[cpool_idx] != JV_CONSTANT_Utf8) | |
| { | |
| // We just ignore errors for now. It isn't clear what is | |
| // best to do here, as an encoding error here means a bug | |
| // either in the compiler or in defineclass.cc. | |
| return NULL; | |
| } | |
| return _Jv_NewStringUtf8Const (constants.data[cpool_idx].utf8); | |
| } | |
| } | |
| jstring | |
| java::lang::Class::getReflectionSignature (::java::lang::reflect::Constructor *c) | |
| { | |
| _Jv_Method *meth = _Jv_FromReflectedConstructor (c); | |
| unsigned short meth_index = meth - methods; | |
| return getReflectionSignature (JV_METHOD_ATTR, meth_index); | |
| } | |
| jstring | |
| java::lang::Class::getReflectionSignature (::java::lang::reflect::Method *m) | |
| { | |
| _Jv_Method *meth = _Jv_FromReflectedMethod (m); | |
| unsigned short meth_index = meth - methods; | |
| return getReflectionSignature (JV_METHOD_ATTR, meth_index); | |
| } | |
| jstring | |
| java::lang::Class::getReflectionSignature (::java::lang::reflect::Field *f) | |
| { | |
| _Jv_Field *fld = _Jv_FromReflectedField (f); | |
| unsigned short fld_index = fld - fields; | |
| return getReflectionSignature (JV_FIELD_ATTR, fld_index); | |
| } | |
| jstring | |
| java::lang::Class::getClassSignature() | |
| { | |
| return getReflectionSignature (JV_CLASS_ATTR, 0); | |
| } | |
| jint | |
| java::lang::Class::getEnclosingMethodData() | |
| { | |
| unsigned char *bytes = reflection_data; | |
| if (bytes == NULL) | |
| return 0; | |
| while (true) | |
| { | |
| int kind = read_u1 (bytes); | |
| if (kind == JV_DONE_ATTR) | |
| return 0; | |
| int len = read_4 (bytes); | |
| unsigned char *next = bytes + len; | |
| if (kind != JV_CLASS_ATTR) | |
| { | |
| bytes = next; | |
| continue; | |
| } | |
| int type = read_u1 (bytes, next); | |
| if (type != JV_ENCLOSING_METHOD_KIND) | |
| { | |
| bytes = next; | |
| continue; | |
| } | |
| int class_index = read_u2 (bytes, next); | |
| int method_index = read_u2 (bytes, next); | |
| _Jv_word result; | |
| _Jv_storeIndexes (&result, class_index, method_index); | |
| return result.i; | |
| } | |
| } | |
| jclass | |
| java::lang::Class::getEnclosingClass() | |
| { | |
| _Jv_word indexes; | |
| indexes.i = getEnclosingMethodData(); | |
| if (indexes.i == 0) | |
| // No enclosing method, but perhaps a member or anonymous class | |
| return getDeclaringClass(); | |
| _Jv_ushort class_index, method_index; | |
| _Jv_loadIndexes (&indexes, class_index, method_index); | |
| return _Jv_Linker::resolve_pool_entry (this, class_index).clazz; | |
| } | |
| ::java::lang::reflect::Method * | |
| java::lang::Class::getEnclosingMethod() | |
| { | |
| _Jv_word indexes; | |
| indexes.i = getEnclosingMethodData(); | |
| if (indexes.i == 0) | |
| return NULL; | |
| _Jv_ushort class_index, method_index; | |
| _Jv_loadIndexes (&indexes, class_index, method_index); | |
| jclass found_class; | |
| _Jv_Method *method = _Jv_Linker::resolve_method_entry (this, found_class, | |
| class_index, | |
| method_index, | |
| false, false); | |
| using namespace java::lang::reflect; | |
| Method *rmethod = new Method (); | |
| rmethod->offset = (char *) method - (char *) found_class->methods; | |
| rmethod->declaringClass = found_class; | |
| return rmethod; | |
| } | |
| ::java::lang::reflect::Constructor * | |
| java::lang::Class::getEnclosingConstructor() | |
| { | |
| _Jv_word indexes; | |
| indexes.i = getEnclosingMethodData(); | |
| if (indexes.i == 0) | |
| return NULL; | |
| _Jv_ushort class_index, method_index; | |
| _Jv_loadIndexes (&indexes, class_index, method_index); | |
| jclass found_class; | |
| _Jv_Method *method = _Jv_Linker::resolve_method_entry (this, found_class, | |
| class_index, | |
| method_index, | |
| false, false); | |
| using namespace java::lang::reflect; | |
| Constructor *cons = new Constructor (); | |
| cons->offset = (char *) method - (char *) found_class->methods; | |
| cons->declaringClass = this; | |
| return cons; | |
| } | |
| static void | |
| check_constant (_Jv_Constants *pool, jint cpool_index, jint type) | |
| { | |
| if (cpool_index <= 0 || cpool_index >= pool->size) | |
| throw new InternalError(JvNewStringLatin1("invalid constant pool index")); | |
| if ((pool->tags[cpool_index] & | |
| ~(JV_CONSTANT_ResolvedFlag|JV_CONSTANT_LazyFlag)) != type) | |
| { | |
| ::java::lang::StringBuffer *sb = new ::java::lang::StringBuffer(); | |
| sb->append(JvNewStringLatin1("expected pool constant ")); | |
| sb->append(type); | |
| sb->append(JvNewStringLatin1(" but got ")); | |
| sb->append(jint (pool->tags[cpool_index])); | |
| throw new InternalError(sb->toString()); | |
| } | |
| } | |
| // Forward declaration | |
| static ::java::lang::annotation::Annotation * | |
| parseAnnotation(jclass klass, _Jv_Constants *pool, | |
| unsigned char *&bytes, unsigned char *last); | |
| static jobject | |
| parseAnnotationElement(jclass klass, _Jv_Constants *pool, | |
| unsigned char *&bytes, unsigned char *last) | |
| { | |
| int tag = read_u1 (bytes, last); | |
| jobject result; | |
| switch (tag) | |
| { | |
| case 'B': | |
| { | |
| int cindex = read_u2 (bytes, last); | |
| check_constant (pool, cindex, JV_CONSTANT_Integer); | |
| result = Byte::valueOf (pool->data[cindex].i); | |
| } | |
| break; | |
| case 'C': | |
| { | |
| int cindex = read_u2 (bytes, last); | |
| check_constant (pool, cindex, JV_CONSTANT_Integer); | |
| result = Character::valueOf (pool->data[cindex].i); | |
| } | |
| break; | |
| case 'S': | |
| { | |
| int cindex = read_u2 (bytes, last); | |
| check_constant (pool, cindex, JV_CONSTANT_Integer); | |
| result = Short::valueOf (pool->data[cindex].i); | |
| } | |
| break; | |
| case 'Z': | |
| { | |
| int cindex = read_u2 (bytes, last); | |
| check_constant (pool, cindex, JV_CONSTANT_Integer); | |
| result = Boolean::valueOf (jboolean (pool->data[cindex].i)); | |
| } | |
| break; | |
| case 'I': | |
| { | |
| int cindex = read_u2 (bytes, last); | |
| check_constant (pool, cindex, JV_CONSTANT_Integer); | |
| result = Integer::valueOf (pool->data[cindex].i); | |
| } | |
| break; | |
| case 'D': | |
| { | |
| int cindex = read_u2 (bytes, last); | |
| check_constant (pool, cindex, JV_CONSTANT_Double); | |
| _Jv_word2 word; | |
| memcpy (&word, &pool->data[cindex], 2 * sizeof (_Jv_word)); | |
| result = Double::valueOf (word.d); | |
| } | |
| break; | |
| case 'F': | |
| { | |
| int cindex = read_u2 (bytes, last); | |
| check_constant (pool, cindex, JV_CONSTANT_Float); | |
| result = Float::valueOf (pool->data[cindex].f); | |
| } | |
| break; | |
| case 'J': | |
| { | |
| int cindex = read_u2 (bytes, last); | |
| check_constant (pool, cindex, JV_CONSTANT_Long); | |
| _Jv_word2 word; | |
| memcpy (&word, &pool->data[cindex], 2 * sizeof (_Jv_word)); | |
| result = Long::valueOf (word.l); | |
| } | |
| break; | |
| case 's': | |
| { | |
| int cindex = read_u2 (bytes, last); | |
| // Despite what the JVM spec says, compilers generate a Utf8 | |
| // constant here, not a String. | |
| check_constant (pool, cindex, JV_CONSTANT_Utf8); | |
| result = pool->data[cindex].utf8->toString(); | |
| } | |
| break; | |
| case 'e': | |
| { | |
| int type_name_index = read_u2 (bytes, last); | |
| check_constant (pool, type_name_index, JV_CONSTANT_Utf8); | |
| int const_name_index = read_u2 (bytes, last); | |
| check_constant (pool, const_name_index, JV_CONSTANT_Utf8); | |
| _Jv_Utf8Const *u_name = pool->data[type_name_index].utf8; | |
| _Jv_Utf8Const *e_name = pool->data[const_name_index].utf8; | |
| // FIXME: throw correct exceptions at the correct times. | |
| jclass e_class = _Jv_FindClassFromSignature(u_name->chars(), | |
| klass->getClassLoaderInternal()); | |
| result = ::java::lang::Enum::valueOf(e_class, e_name->toString()); | |
| } | |
| break; | |
| case 'c': | |
| { | |
| int cindex = read_u2 (bytes, last); | |
| check_constant (pool, cindex, JV_CONSTANT_Utf8); | |
| _Jv_Utf8Const *u_name = pool->data[cindex].utf8; | |
| jclass anno_class | |
| = _Jv_FindClassFromSignatureNoException(u_name->chars(), | |
| klass->getClassLoaderInternal()); | |
| // FIXME: not correct: we should lazily do this when trying to | |
| // read the element. This means that | |
| // AnnotationInvocationHandler needs to have a special case. | |
| if (! anno_class) | |
| // FIXME: original exception... | |
| throw new TypeNotPresentException(u_name->toString(), NULL); | |
| result = anno_class; | |
| } | |
| break; | |
| case '@': | |
| result = parseAnnotation (klass, pool, bytes, last); | |
| break; | |
| case '[': | |
| { | |
| int n_array_elts = read_u2 (bytes, last); | |
| jobjectArray aresult = _Jv_NewObjectArray (n_array_elts, | |
| &Object::class$, NULL); | |
| jobject *elts = elements (aresult); | |
| for (int i = 0; i < n_array_elts; ++i) | |
| elts[i] = parseAnnotationElement(klass, pool, bytes, last); | |
| result = aresult; | |
| } | |
| break; | |
| default: | |
| throw new java::lang::InternalError(); | |
| } | |
| return result; | |
| } | |
| static ::java::lang::annotation::Annotation * | |
| parseAnnotation(jclass klass, _Jv_Constants *pool, | |
| unsigned char *&bytes, unsigned char *last) | |
| { | |
| int type_index = read_u2 (bytes, last); | |
| check_constant (pool, type_index, JV_CONSTANT_Utf8); | |
| _Jv_Utf8Const *u_name = pool->data[type_index].utf8; | |
| jclass anno_class = _Jv_FindClassFromSignatureNoException(u_name->chars(), | |
| klass->getClassLoaderInternal()); | |
| // FIXME: what to do if anno_class==NULL? | |
| ::java::util::HashMap *hmap = new ::java::util::HashMap(); | |
| int npairs = read_u2 (bytes, last); | |
| for (int i = 0; i < npairs; ++i) | |
| { | |
| int name_index = read_u2 (bytes, last); | |
| check_constant (pool, name_index, JV_CONSTANT_Utf8); | |
| jstring name = _Jv_NewStringUtf8Const (pool->data[name_index].utf8); | |
| jobject value = parseAnnotationElement (klass, pool, bytes, last); | |
| // FIXME: any checks needed for name? | |
| hmap->put(name, value); | |
| } | |
| using namespace ::sun::reflect::annotation; | |
| return AnnotationInvocationHandler::create (anno_class, | |
| (::java::util::Map *) hmap); | |
| } | |
| static jobjectArray | |
| parseAnnotations(jclass klass, _Jv_Constants *pool, | |
| unsigned char *&bytes, unsigned char *last) | |
| { | |
| int num = read_u2 (bytes, last); | |
| jobjectArray result = _Jv_NewObjectArray (num, | |
| &::java::lang::annotation::Annotation::class$, | |
| NULL); | |
| jobject *elts = elements (result); | |
| for (int i = 0; i < num; ++i) | |
| elts[i] = parseAnnotation(klass, pool, bytes, last); | |
| return result; | |
| } | |
| static jobjectArray | |
| parseParameterAnnotations(jclass klass, _Jv_Constants *pool, | |
| unsigned char *&bytes, unsigned char *last) | |
| { | |
| jclass anno = &::java::lang::annotation::Annotation::class$; | |
| jclass annoary = _Jv_GetArrayClass (anno, anno->getClassLoaderInternal()); | |
| // FIXME: something should check the number of params versus the | |
| // method | |
| int n_params = read_u1 (bytes, last); | |
| jobjectArray result = _Jv_NewObjectArray (n_params, annoary, NULL); | |
| jobject *elts = elements (result); | |
| for (int i = 0; i < n_params; ++i) | |
| elts[i] = parseAnnotations(klass, pool, bytes, last); | |
| return result; | |
| } | |
| jobject | |
| java::lang::Class::getMethodDefaultValue(::java::lang::reflect::Method *meth) | |
| { | |
| // FIXME: could cache the value here... | |
| unsigned char *bytes = reflection_data; | |
| if (bytes == NULL) | |
| return 0; | |
| unsigned short meth_index = _Jv_FromReflectedMethod (meth) - methods; | |
| while (true) | |
| { | |
| int type = read_u1 (bytes); | |
| if (type == JV_DONE_ATTR) | |
| return NULL; | |
| int len = read_4 (bytes); | |
| unsigned char *next = bytes + len; | |
| if (type != JV_METHOD_ATTR) | |
| { | |
| bytes = next; | |
| continue; | |
| } | |
| int kind = read_u1 (bytes, next); | |
| if (kind != JV_ANNOTATION_DEFAULT_KIND) | |
| { | |
| bytes = next; | |
| continue; | |
| } | |
| int index = read_u2 (bytes, next); | |
| if (meth_index != index) | |
| { | |
| bytes = next; | |
| continue; | |
| } | |
| // FIXME: could cache here. If we do then we have to clone any | |
| // array result. | |
| return parseAnnotationElement(this, &this->constants, bytes, next); | |
| } | |
| } | |
| jobjectArray | |
| java::lang::Class::getDeclaredAnnotations(jint /* jv_attr_type */ member_type, | |
| jint member_index, | |
| jint /* jv_attr_kind */ kind_req) | |
| { | |
| using namespace java::lang::annotation; | |
| jobjectArray result; | |
| unsigned char *bytes = reflection_data; | |
| if (bytes == NULL) | |
| return 0; | |
| if (loader == NULL) | |
| loader = (ClassLoader *)VMClassLoader::bootLoader; | |
| result = (loader->getDeclaredAnnotations | |
| (this, member_type, member_index, kind_req)); | |
| if (result) | |
| return result; | |
| for (;;) | |
| { | |
| int type = read_u1 (bytes); | |
| if (type == JV_DONE_ATTR) | |
| return NULL; | |
| int len = read_4 (bytes); | |
| unsigned char *next = bytes + len; | |
| if (type != member_type) | |
| { | |
| bytes = next; | |
| continue; | |
| } | |
| int kind = read_u1 (bytes, next); | |
| if (kind != kind_req) | |
| { | |
| bytes = next; | |
| continue; | |
| } | |
| if (member_type != JV_CLASS_ATTR) | |
| { | |
| int index = read_u2 (bytes, next); | |
| if (member_index != index) | |
| { | |
| bytes = next; | |
| continue; | |
| } | |
| } | |
| if (kind_req == JV_PARAMETER_ANNOTATIONS_KIND) | |
| result = ((parseParameterAnnotations | |
| (this, &this->constants, bytes, next))); | |
| else | |
| result = ((parseAnnotations (this, &this->constants, bytes, next))); | |
| break; | |
| } | |
| return (loader->putDeclaredAnnotations | |
| (this, member_type, member_index, kind_req, result)); | |
| } | |
| jobjectArray | |
| java::lang::Class::getDeclaredAnnotations(::java::lang::reflect::Method *meth, | |
| jboolean is_param) | |
| { | |
| unsigned short meth_index = _Jv_FromReflectedMethod (meth) - methods; | |
| return getDeclaredAnnotations(JV_METHOD_ATTR, meth_index, | |
| (is_param | |
| ? JV_PARAMETER_ANNOTATIONS_KIND | |
| : JV_ANNOTATIONS_KIND)); | |
| } | |
| jobjectArray | |
| java::lang::Class::getDeclaredAnnotations(::java::lang::reflect::Constructor *cons, | |
| jboolean is_param) | |
| { | |
| unsigned short meth_index = _Jv_FromReflectedConstructor (cons) - methods; | |
| return getDeclaredAnnotations(JV_METHOD_ATTR, meth_index, | |
| (is_param | |
| ? JV_PARAMETER_ANNOTATIONS_KIND | |
| : JV_ANNOTATIONS_KIND)); | |
| } | |
| jobjectArray | |
| java::lang::Class::getDeclaredAnnotations(::java::lang::reflect::Field *fld) | |
| { | |
| unsigned short field_index = _Jv_FromReflectedField (fld) - fields; | |
| return getDeclaredAnnotations(JV_FIELD_ATTR, field_index, | |
| JV_ANNOTATIONS_KIND); | |
| } | |
| JArray< ::java::lang::annotation::Annotation *> * | |
| java::lang::Class::getDeclaredAnnotationsInternal() | |
| { | |
| return (JArray< ::java::lang::annotation::Annotation *> *) getDeclaredAnnotations(JV_CLASS_ATTR, 0, JV_ANNOTATIONS_KIND); | |
| } | |
| static jclass | |
| resolve_class_constant (jclass klass, _Jv_Constants *pool, int cpool_index) | |
| { | |
| check_constant (pool, cpool_index, JV_CONSTANT_Class); | |
| // FIXME: what is the correct thing to do with an exception here? | |
| return _Jv_Linker::resolve_pool_entry (klass, cpool_index, false).clazz; | |
| } | |
| jint | |
| java::lang::Class::findInnerClassAttribute() | |
| { | |
| unsigned char *bytes = reflection_data; | |
| if (bytes == NULL) | |
| return -1; | |
| while (true) | |
| { | |
| int type = read_u1 (bytes); | |
| if (type == JV_DONE_ATTR) | |
| break; | |
| // After the type but before the length. | |
| unsigned char *save = bytes; | |
| int len = read_4 (bytes); | |
| unsigned char *next = bytes + len; | |
| if (type != JV_CLASS_ATTR) | |
| { | |
| bytes = next; | |
| continue; | |
| } | |
| int kind = read_u1 (bytes, next); | |
| if (kind != JV_INNER_CLASSES_KIND) | |
| { | |
| bytes = next; | |
| continue; | |
| } | |
| return save - reflection_data; | |
| } | |
| return -1; | |
| } | |
| jint | |
| java::lang::Class::findDeclaredClasses(JArray<jclass> *result, | |
| jboolean publicOnly, | |
| jint offset) | |
| { | |
| unsigned char *bytes = reflection_data + offset; | |
| int len = read_4 (bytes); | |
| unsigned char *next = bytes + len; | |
| // Skip a byte. | |
| read_u1 (bytes, next); | |
| int n_classes = read_u2 (bytes, next); | |
| int count = 0; | |
| for (int i = 0; i < n_classes; ++i) | |
| { | |
| int inner_class_index = read_u2 (bytes, next); | |
| int outer_class_index = read_u2 (bytes, next); | |
| /*int inner_name_index = */ read_u2 (bytes, next); | |
| int inner_flags = read_u2 (bytes, next); | |
| if (inner_class_index == 0 || outer_class_index == 0) | |
| continue; | |
| if (resolve_class_constant (this, &constants, outer_class_index) == this) | |
| { | |
| jclass inner = resolve_class_constant (this, &constants, | |
| inner_class_index); | |
| if (! publicOnly | |
| || ((inner_flags | |
| & java::lang::reflect::Modifier::PUBLIC) != 0)) | |
| { | |
| if (result) | |
| { | |
| jclass *elts = elements (result); | |
| elts[count] = inner; | |
| } | |
| ++count; | |
| } | |
| } | |
| } | |
| return count; | |
| } | |
| JArray<jclass> * | |
| java::lang::Class::getDeclaredClasses (jboolean publicOnly) | |
| { | |
| int offset = findInnerClassAttribute(); | |
| int count; | |
| if (offset == -1) | |
| { | |
| // No InnerClasses attribute, so no declared classes. | |
| count = 0; | |
| } | |
| else | |
| count = findDeclaredClasses(NULL, publicOnly, offset); | |
| JArray<jclass> *result | |
| = (JArray<jclass> *) JvNewObjectArray (count, &java::lang::Class::class$, | |
| NULL); | |
| if (count > 0) | |
| findDeclaredClasses(result, publicOnly, offset); | |
| return result; | |
| } | |
| jclass | |
| java::lang::Class::getDeclaringClass (void) | |
| { | |
| int offset = findInnerClassAttribute(); | |
| if (offset == -1) | |
| return NULL; | |
| unsigned char *bytes = reflection_data + offset; | |
| int len = read_4 (bytes); | |
| unsigned char *next = bytes + len; | |
| // Skip a byte. | |
| read_u1 (bytes, next); | |
| int n_classes = read_u2 (bytes, next); | |
| for (int i = 0; i < n_classes; ++i) | |
| { | |
| int inner_class_index = read_u2 (bytes, next); | |
| int outer_class_index = read_u2 (bytes, next); | |
| /*int inner_name_index = */read_u2 (bytes, next); | |
| /*int inner_flags = */read_u2 (bytes, next); | |
| if (inner_class_index == 0 || outer_class_index == 0) | |
| continue; | |
| if (resolve_class_constant (this, &constants, inner_class_index) == this) | |
| return resolve_class_constant (this, &constants, outer_class_index); | |
| } | |
| return NULL; | |
| } | |
| jboolean | |
| java::lang::Class::isAnonymousClass() | |
| { | |
| int offset = findInnerClassAttribute(); | |
| if (offset == -1) | |
| return false; | |
| unsigned char *bytes = reflection_data + offset; | |
| int len = read_4 (bytes); | |
| unsigned char *next = bytes + len; | |
| // Skip a byte. | |
| read_u1 (bytes, next); | |
| int n_classes = read_u2 (bytes, next); | |
| for (int i = 0; i < n_classes; ++i) | |
| { | |
| int inner_class_index = read_u2 (bytes, next); | |
| /*int outer_class_index = */read_u2 (bytes, next); | |
| int inner_name_index = read_u2 (bytes, next); | |
| /*int inner_flags = */read_u2 (bytes, next); | |
| if (inner_class_index == 0) | |
| continue; | |
| if (resolve_class_constant (this, &constants, inner_class_index) == this) | |
| return inner_name_index == 0; | |
| } | |
| return false; | |
| } | |
| jboolean | |
| java::lang::Class::isLocalClass() | |
| { | |
| _Jv_word indexes; | |
| indexes.i = getEnclosingMethodData(); | |
| return indexes.i != 0; | |
| } | |
| jboolean | |
| java::lang::Class::isMemberClass() | |
| { | |
| // FIXME: is this correct? | |
| return !isLocalClass() && getDeclaringClass() != NULL; | |
| } | |
| // | |
| // Some class-related convenience functions. | |
| // | |
| // Find a method declared in the class. If it is not declared locally | |
| // (or if it is inherited), return NULL. | |
| _Jv_Method * | |
| _Jv_GetMethodLocal (jclass klass, _Jv_Utf8Const *name, | |
| _Jv_Utf8Const *signature) | |
| { | |
| for (int i = 0; i < klass->method_count; ++i) | |
| { | |
| if (_Jv_equalUtf8Consts (name, klass->methods[i].name) | |
| && _Jv_equalUtf8Consts (signature, klass->methods[i].signature)) | |
| return &klass->methods[i]; | |
| } | |
| return NULL; | |
| } | |
| _Jv_Method * | |
| _Jv_LookupDeclaredMethod (jclass klass, _Jv_Utf8Const *name, | |
| _Jv_Utf8Const *signature, | |
| jclass *declarer_result) | |
| { | |
| for (; klass; klass = klass->getSuperclass()) | |
| { | |
| _Jv_Method *meth = _Jv_GetMethodLocal (klass, name, signature); | |
| if (meth) | |
| { | |
| if (declarer_result) | |
| *declarer_result = klass; | |
| return meth; | |
| } | |
| } | |
| return NULL; | |
| } | |
| java::lang::reflect::Method * | |
| _Jv_GetReflectedMethod (jclass klass, _Jv_Utf8Const *name, | |
| _Jv_Utf8Const *signature) | |
| { | |
| for (; klass; klass = klass->getSuperclass()) | |
| { | |
| _Jv_Method *meth = _Jv_GetMethodLocal (klass, name, signature); | |
| if (meth) | |
| { | |
| using namespace java::lang::reflect; | |
| Method *rmethod = new Method (); | |
| rmethod->offset = (char*) meth - (char*) klass->methods; | |
| rmethod->declaringClass = klass; | |
| return rmethod; | |
| } | |
| } | |
| return NULL; | |
| } | |
| #ifdef HAVE_TLS | |
| // NOTE: MCACHE_SIZE should be a power of 2 minus one. | |
| #define MCACHE_SIZE 31 | |
| struct _Jv_mcache | |
| { | |
| jclass klass; | |
| _Jv_Method *method; | |
| }; | |
| static __thread _Jv_mcache *method_cache; | |
| #endif // HAVE_TLS | |
| static void * | |
| _Jv_FindMethodInCache (jclass klass MAYBE_UNUSED, | |
| _Jv_Utf8Const *name MAYBE_UNUSED, | |
| _Jv_Utf8Const *signature MAYBE_UNUSED) | |
| { | |
| #ifdef HAVE_TLS | |
| _Jv_mcache *cache = method_cache; | |
| if (cache) | |
| { | |
| int index = name->hash16 () & MCACHE_SIZE; | |
| _Jv_mcache *mc = &cache[index]; | |
| _Jv_Method *m = mc->method; | |
| if (mc->klass == klass | |
| && _Jv_equalUtf8Consts (m->name, name) | |
| && _Jv_equalUtf8Consts (m->signature, signature)) | |
| return mc->method->ncode; | |
| } | |
| #endif // HAVE_TLS | |
| return NULL; | |
| } | |
| static void | |
| _Jv_AddMethodToCache (jclass klass MAYBE_UNUSED, | |
| _Jv_Method *method MAYBE_UNUSED) | |
| { | |
| #ifdef HAVE_TLS | |
| if (method_cache == NULL) | |
| method_cache = (_Jv_mcache *) _Jv_MallocUnchecked((MCACHE_SIZE + 1) | |
| * sizeof (_Jv_mcache)); | |
| // If the allocation failed, just keep going. | |
| if (method_cache != NULL) | |
| { | |
| int index = method->name->hash16 () & MCACHE_SIZE; | |
| method_cache[index].method = method; | |
| method_cache[index].klass = klass; | |
| } | |
| #endif // HAVE_TLS | |
| } | |
| // Free this thread's method cache. We explicitly manage this memory | |
| // as the GC does not yet know how to scan TLS on all platforms. | |
| void | |
| _Jv_FreeMethodCache () | |
| { | |
| #ifdef HAVE_TLS | |
| if (method_cache != NULL) | |
| { | |
| _Jv_Free(method_cache); | |
| method_cache = NULL; | |
| } | |
| #endif // HAVE_TLS | |
| } | |
| void * | |
| _Jv_LookupInterfaceMethod (jclass klass, _Jv_Utf8Const *name, | |
| _Jv_Utf8Const *signature) | |
| { | |
| using namespace java::lang::reflect; | |
| void *ncode = _Jv_FindMethodInCache (klass, name, signature); | |
| if (ncode != 0) | |
| return ncode; | |
| for (; klass; klass = klass->getSuperclass()) | |
| { | |
| _Jv_Method *meth = _Jv_GetMethodLocal (klass, name, signature); | |
| if (! meth) | |
| continue; | |
| if (Modifier::isStatic(meth->accflags)) | |
| throw new java::lang::IncompatibleClassChangeError | |
| (_Jv_GetMethodString (klass, meth)); | |
| if (Modifier::isAbstract(meth->accflags)) | |
| throw new java::lang::AbstractMethodError | |
| (_Jv_GetMethodString (klass, meth)); | |
| if (! Modifier::isPublic(meth->accflags)) | |
| throw new java::lang::IllegalAccessError | |
| (_Jv_GetMethodString (klass, meth)); | |
| _Jv_AddMethodToCache (klass, meth); | |
| return meth->ncode; | |
| } | |
| throw new java::lang::IncompatibleClassChangeError; | |
| } | |
| // Fast interface method lookup by index. | |
| void * | |
| _Jv_LookupInterfaceMethodIdx (jclass klass, jclass iface, int method_idx) | |
| { | |
| _Jv_IDispatchTable *cldt = klass->idt; | |
| int idx = iface->ioffsets[cldt->iindex] + method_idx; | |
| return cldt->itable[idx]; | |
| } | |
| jboolean | |
| _Jv_IsAssignableFrom (jclass source, jclass target) | |
| { | |
| if (source == target) | |
| return true; | |
| // If target is array, so must source be. | |
| while (target->isArray ()) | |
| { | |
| if (! source->isArray()) | |
| return false; | |
| target = target->getComponentType(); | |
| source = source->getComponentType(); | |
| } | |
| if (target->isInterface()) | |
| { | |
| // Abstract classes have no IDT, and IDTs provide no way to check | |
| // two interfaces for assignability. | |
| if (__builtin_expect | |
| (source->idt == NULL || source->isInterface(), false)) | |
| return _Jv_InterfaceAssignableFrom (source, target); | |
| _Jv_IDispatchTable *cl_idt = source->idt; | |
| if (__builtin_expect ((target->ioffsets == NULL), false)) | |
| return false; // No class implementing TARGET has been loaded. | |
| jshort cl_iindex = cl_idt->iindex; | |
| if (cl_iindex < target->ioffsets[0]) | |
| { | |
| jshort offset = target->ioffsets[cl_iindex]; | |
| if (offset != -1 && offset < cl_idt->itable_length | |
| && cl_idt->itable[offset] == target) | |
| return true; | |
| } | |
| return false; | |
| } | |
| // Primitive TYPE classes are only assignable to themselves. | |
| if (__builtin_expect (target->isPrimitive() || source->isPrimitive(), false)) | |
| return false; | |
| if (target == &java::lang::Object::class$) | |
| return true; | |
| else if (source->ancestors == NULL || target->ancestors == NULL) | |
| { | |
| // We need this case when either SOURCE or TARGET has not has | |
| // its constant-time tables prepared. | |
| // At this point we know that TARGET can't be Object, so it is | |
| // safe to use that as the termination point. | |
| while (source && source != &java::lang::Object::class$) | |
| { | |
| if (source == target) | |
| return true; | |
| source = source->getSuperclass(); | |
| } | |
| } | |
| else if (source->depth >= target->depth | |
| && source->ancestors[source->depth - target->depth] == target) | |
| return true; | |
| return false; | |
| } | |
| // Interface type checking, the slow way. Returns TRUE if IFACE is a | |
| // superinterface of SOURCE. This is used when SOURCE is also an interface, | |
| // or a class with no interface dispatch table. | |
| jboolean | |
| _Jv_InterfaceAssignableFrom (jclass source, jclass iface) | |
| { | |
| for (int i = 0; i < source->interface_count; i++) | |
| { | |
| jclass interface = source->interfaces[i]; | |
| if (iface == interface | |
| || _Jv_InterfaceAssignableFrom (interface, iface)) | |
| return true; | |
| } | |
| if (!source->isInterface() | |
| && source->superclass | |
| && _Jv_InterfaceAssignableFrom (source->superclass, iface)) | |
| return true; | |
| return false; | |
| } | |
| jboolean | |
| _Jv_IsInstanceOf(jobject obj, jclass cl) | |
| { | |
| if (__builtin_expect (!obj, false)) | |
| return false; | |
| return _Jv_IsAssignableFrom (JV_CLASS (obj), cl); | |
| } | |
| void * | |
| _Jv_CheckCast (jclass c, jobject obj) | |
| { | |
| if (__builtin_expect | |
| (obj != NULL && ! _Jv_IsAssignableFrom(JV_CLASS (obj), c), false)) | |
| throw new java::lang::ClassCastException | |
| ((new java::lang::StringBuffer | |
| (obj->getClass()->getName()))->append | |
| (JvNewStringUTF(" cannot be cast to "))->append | |
| (c->getName())->toString()); | |
| return obj; | |
| } | |
| void | |
| _Jv_CheckArrayStore (jobject arr, jobject obj) | |
| { | |
| if (obj) | |
| { | |
| JvAssert (arr != NULL); | |
| jclass elt_class = (JV_CLASS (arr))->getComponentType(); | |
| if (elt_class == &java::lang::Object::class$) | |
| return; | |
| jclass obj_class = JV_CLASS (obj); | |
| if (__builtin_expect | |
| (! _Jv_IsAssignableFrom (obj_class, elt_class), false)) | |
| throw new java::lang::ArrayStoreException | |
| ((new java::lang::StringBuffer | |
| (JvNewStringUTF("Cannot store ")))->append | |
| (obj_class->getName())->append | |
| (JvNewStringUTF(" in array of type "))->append | |
| (elt_class->getName())->toString()); | |
| } | |
| } | |
| jboolean | |
| _Jv_IsAssignableFromSlow (jclass source, jclass target) | |
| { | |
| // First, strip arrays. | |
| while (target->isArray ()) | |
| { | |
| // If target is array, source must be as well. | |
| if (! source->isArray ()) | |
| return false; | |
| target = target->getComponentType (); | |
| source = source->getComponentType (); | |
| } | |
| // Quick success. | |
| if (target == &java::lang::Object::class$) | |
| return true; | |
| // Ensure that the classes have their supers installed. | |
| _Jv_Linker::wait_for_state (source, JV_STATE_LOADING); | |
| _Jv_Linker::wait_for_state (target, JV_STATE_LOADING); | |
| do | |
| { | |
| if (source == target) | |
| return true; | |
| if (target->isPrimitive () || source->isPrimitive ()) | |
| return false; | |
| if (target->isInterface ()) | |
| { | |
| for (int i = 0; i < source->interface_count; ++i) | |
| { | |
| // We use a recursive call because we also need to | |
| // check superinterfaces. | |
| if (_Jv_IsAssignableFromSlow (source->getInterface (i), target)) | |
| return true; | |
| } | |
| } | |
| source = source->getSuperclass (); | |
| } | |
| while (source != NULL); | |
| return false; | |
| } | |
| // Lookup an interface method by name. This is very similar to | |
| // purpose to _getMethod, but the interfaces are quite different. It | |
| // might be a good idea for _getMethod to call this function. | |
| // | |
| // Return true of the method is found, with the class in FOUND_CLASS | |
| // and the index in INDEX. | |
| bool | |
| _Jv_getInterfaceMethod (jclass search_class, jclass &found_class, int &index, | |
| const _Jv_Utf8Const *utf_name, | |
| const _Jv_Utf8Const *utf_sig) | |
| { | |
| for (jclass klass = search_class; klass; klass = klass->getSuperclass()) | |
| { | |
| // FIXME: Throw an exception? | |
| if (!klass->isInterface ()) | |
| return false; | |
| int max = klass->method_count; | |
| int offset = 0; | |
| for (int i = 0; i < max; ++i) | |
| { | |
| // Skip <clinit> here, as it will not be in the IDT. | |
| if (klass->methods[i].name->first() == '<') | |
| continue; | |
| if (_Jv_equalUtf8Consts (klass->methods[i].name, utf_name) | |
| && _Jv_equalUtf8Consts (klass->methods[i].signature, utf_sig)) | |
| { | |
| // Found it. | |
| using namespace java::lang::reflect; | |
| // FIXME: Method must be public. Throw an exception? | |
| if (! Modifier::isPublic (klass->methods[i].accflags)) | |
| break; | |
| found_class = klass; | |
| // Interface method indexes count from 1. | |
| index = offset + 1; | |
| return true; | |
| } | |
| ++offset; | |
| } | |
| } | |
| // If we haven't found a match, and this class is an interface, then | |
| // check all the superinterfaces. | |
| if (search_class->isInterface()) | |
| { | |
| for (int i = 0; i < search_class->interface_count; ++i) | |
| { | |
| using namespace java::lang::reflect; | |
| bool found = _Jv_getInterfaceMethod (search_class->interfaces[i], | |
| found_class, index, | |
| utf_name, utf_sig); | |
| if (found) | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| #ifdef INTERPRETER | |
| _Jv_MethodBase * | |
| _Jv_FindInterpreterMethod (jclass klass, jmethodID desired_method) | |
| { | |
| using namespace java::lang::reflect; | |
| _Jv_InterpClass *iclass | |
| = reinterpret_cast<_Jv_InterpClass *> (klass->aux_info); | |
| _Jv_MethodBase **imethods = _Jv_GetFirstMethod (iclass); | |
| for (int i = 0; i < JvNumMethods (klass); ++i) | |
| { | |
| _Jv_MethodBase *imeth = imethods[i]; | |
| if (imeth->get_method () == desired_method) | |
| return imeth; | |
| } | |
| return NULL; | |
| } | |
| #endif | |
| // Return Utf8 name of a class. This function is here for code that | |
| // can't access klass->name directly. | |
| _Jv_Utf8Const* | |
| _Jv_GetClassNameUtf8 (jclass klass) | |
| { | |
| return klass->name; | |
| } | |
| jclass | |
| _Jv_GetMethodDeclaringClass (jmethodID method) | |
| { | |
| _Jv_StackTrace::UpdateNCodeMap (); | |
| jobject obj = reinterpret_cast<jobject> (method->ncode); | |
| return reinterpret_cast<jclass> (_Jv_StackTrace::ncodeMap->get (obj)); | |
| } | |
| jbyte | |
| _Jv_GetClassState (jclass klass) | |
| { | |
| return klass->state; | |
| } | |
| #ifdef INTERPRETER | |
| jstring | |
| _Jv_GetInterpClassSourceFile (jclass klass) | |
| { | |
| if (_Jv_IsInterpretedClass (klass)) | |
| { | |
| _Jv_InterpClass *iclass = | |
| reinterpret_cast<_Jv_InterpClass *> (klass->aux_info); | |
| return iclass->source_file_name; | |
| } | |
| return NULL; | |
| } | |
| #endif |