// Class.h - Header file for java.lang.Class. -*- c++ -*-
-/* Copyright (C) 1998, 1999, 2000 Red Hat, Inc.
+/* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation
This file is part of libgcj.
#include <java/lang/Object.h>
#include <java/lang/String.h>
#include <java/net/URL.h>
+#include <java/lang/reflect/Modifier.h>
+#include <java/security/ProtectionDomain.h>
+#include <java/lang/Package.h>
+#include <gnu/gcj/runtime/StackTrace.h>
// We declare these here to avoid including gcj/cni.h.
extern "C" void _Jv_InitClass (jclass klass);
extern "C" void _Jv_RegisterClasses (jclass *classes);
+// This must be predefined with "C" linkage.
+extern "C" void *_Jv_LookupInterfaceMethodIdx (jclass klass, jclass iface,
+ int meth_idx);
+
// These are the possible values for the `state' field of the class
// structure. Note that ordering is important here. Whenever the
// state changes, one should notify all waiters of this class.
JV_STATE_LINKED = 9, // Strings interned.
JV_STATE_IN_PROGRESS = 10, // <Clinit> running.
- JV_STATE_DONE = 12, //
- JV_STATE_ERROR = 14 // must be last.
+ JV_STATE_ERROR = 12,
+
+ JV_STATE_DONE = 14 // Must be last.
};
struct _Jv_Field;
struct _Jv_VTable;
+union _Jv_word;
+struct _Jv_ArrayVTable;
struct _Jv_Constants
{
struct _Jv_Method
{
+ // Method name.
_Jv_Utf8Const *name;
+ // Method signature.
_Jv_Utf8Const *signature;
+ // Access flags.
_Jv_ushort accflags;
+ // Method's index in the vtable.
+ _Jv_ushort index;
+ // Pointer to underlying function.
void *ncode;
+ // NULL-terminated list of exception class names; can be NULL if
+ // there are none such.
+ _Jv_Utf8Const **throws;
_Jv_Method *getNextMethod ()
{ return this + 1; }
};
+// Interface Dispatch Tables
+union _Jv_IDispatchTable
+{
+ struct
+ {
+ // Index into interface's ioffsets.
+ jshort iindex;
+ jshort itable_length;
+ // Class Interface dispatch table.
+ void **itable;
+ } cls;
+
+ struct
+ {
+ // Offsets into implementation class itables.
+ jshort *ioffsets;
+ } iface;
+};
+
+// Used by _Jv_GetInterfaces ()
+struct _Jv_ifaces
+{
+ jclass *list;
+ jshort len;
+ jshort count;
+};
+
+struct _Jv_MethodSymbol
+{
+ _Jv_Utf8Const *class_name;
+ _Jv_Utf8Const *name;
+ _Jv_Utf8Const *signature;
+};
+
+struct _Jv_OffsetTable
+{
+ jint state;
+ jint offsets[];
+};
+
+struct _Jv_AddressTable
+{
+ jint state;
+ void *addresses[];
+};
+
#define JV_PRIMITIVE_VTABLE ((_Jv_VTable *) -1)
+#define JV_CLASS(Obj) ((jclass) (*(_Jv_VTable **) Obj)->clas)
+
class java::lang::Class : public java::lang::Object
{
public:
+ static jclass forName (jstring className, jboolean initialize,
+ java::lang::ClassLoader *loader);
static jclass forName (jstring className);
JArray<jclass> *getClasses (void);
- java::lang::ClassLoader *getClassLoader (void)
- {
- return loader;
- }
+ java::lang::ClassLoader *getClassLoader (void);
- jclass getComponentType (void)
- {
- return isArray () ? (* (jclass *) &methods) : 0;
- }
+ // This is an internal method that circumvents the usual security
+ // checks when getting the class loader.
+ java::lang::ClassLoader *getClassLoaderInternal (void)
+ {
+ return loader;
+ }
java::lang::reflect::Constructor *getConstructor (JArray<jclass> *);
JArray<java::lang::reflect::Constructor *> *getConstructors (void);
java::lang::reflect::Field *getField (jstring, jint);
jint _getMethods (JArray<java::lang::reflect::Method *> *result,
jint offset);
+ java::lang::reflect::Field *getPrivateField (jstring);
+ java::lang::reflect::Method *getPrivateMethod (jstring, JArray<jclass> *);
+ java::security::ProtectionDomain *getProtectionDomain0 ();
+
+ java::lang::reflect::Method *_getMethod (jstring, JArray<jclass> *);
+ java::lang::reflect::Method *_getDeclaredMethod (jstring, JArray<jclass> *);
+
public:
JArray<java::lang::reflect::Field *> *getFields (void);
void getSignature (java::lang::StringBuffer *buffer);
static jstring getSignature (JArray<jclass> *, jboolean is_constructor);
- java::lang::reflect::Method *getMethod (jstring, JArray<jclass> *);
JArray<java::lang::reflect::Method *> *getMethods (void);
- jint getModifiers (void)
- {
- return accflags;
- }
+ inline jint getModifiers (void)
+ {
+ return accflags & java::lang::reflect::Modifier::ALL_FLAGS;
+ }
jstring getName (void);
java::net::URL *getResource (jstring resourceName);
java::io::InputStream *getResourceAsStream (jstring resourceName);
JArray<jobject> *getSigners (void);
+ void setSigners(JArray<jobject> *);
- jclass getSuperclass (void)
+ inline jclass getSuperclass (void)
{
return superclass;
}
- jboolean isArray (void)
+ inline jboolean isArray (void)
{
return name->data[0] == '[';
}
+ inline jclass getComponentType (void)
+ {
+ return isArray () ? (* (jclass *) &methods) : 0;
+ }
+
jboolean isAssignableFrom (jclass cls);
jboolean isInstance (jobject obj);
- jboolean isInterface (void);
- jboolean isPrimitive (void)
+ inline jboolean isInterface (void)
+ {
+ return (accflags & java::lang::reflect::Modifier::INTERFACE) != 0;
+ }
+
+ inline jboolean isPrimitive (void)
{
return vtable == JV_PRIMITIVE_VTABLE;
}
jobject newInstance (void);
+ java::security::ProtectionDomain *getProtectionDomain (void);
+ java::lang::Package *getPackage (void);
jstring toString (void);
+ jboolean desiredAssertionStatus (void);
// FIXME: this probably shouldn't be public.
jint size (void)
{
return size_in_bytes;
}
-
+
// finalization
void finalize ();
-private:
- void checkMemberAccess (jint flags);
+ // This constructor is used to create Class object for the primitive
+ // types. See prims.cc.
+ Class ();
+
+ static java::lang::Class class$;
+
+private:
+
+ void memberAccessCheck (jint flags);
- // Various functions to handle class initialization.
- java::lang::Throwable *hackTrampoline (jint, java::lang::Throwable *);
- void hackRunInitializers (void);
void initializeClass (void);
+ static jstring getPackagePortion (jstring);
+
// Friend functions implemented in natClass.cc.
friend _Jv_Method *_Jv_GetMethodLocal (jclass klass, _Jv_Utf8Const *name,
_Jv_Utf8Const *signature);
+ friend jboolean _Jv_IsAssignableFrom(jclass, jclass);
+ friend jboolean _Jv_InterfaceAssignableFrom (jclass, jclass);
+ friend void *_Jv_LookupInterfaceMethodIdx (jclass klass, jclass iface,
+ int method_idx);
+
+ inline friend void
+ _Jv_InitClass (jclass klass)
+ {
+ if (__builtin_expect (klass->state == JV_STATE_DONE, true))
+ return;
+ klass->initializeClass ();
+ }
+
friend _Jv_Method* _Jv_LookupDeclaredMethod (jclass, _Jv_Utf8Const *,
_Jv_Utf8Const*);
- friend void _Jv_InitClass (jclass klass);
-
friend jfieldID JvGetFirstInstanceField (jclass);
friend jint JvNumInstanceFields (jclass);
friend jfieldID JvGetFirstStaticField (jclass);
friend jint JvNumStaticFields (jclass);
friend jobject _Jv_AllocObject (jclass, jint);
- friend jobjectArray _Jv_NewObjectArray (jsize, jclass, jobject);
- friend jobject _Jv_NewPrimArray (jclass, jint);
+ friend void *_Jv_AllocObj (jint, jclass);
+ friend void *_Jv_AllocPtrFreeObj (jint, jclass);
+ friend void *_Jv_AllocArray (jint, jclass);
friend jobject _Jv_JNI_ToReflectedField (_Jv_JNIEnv *, jclass, jfieldID,
jboolean);
friend jint JvNumMethods (jclass);
friend jmethodID JvGetFirstMethod (jclass);
- friend class _Jv_PrimClass;
-
// Friends classes and functions to implement the ClassLoader
friend class java::lang::ClassLoader;
+ friend class java::lang::VMClassLoader;
+
+ friend class java::io::ObjectOutputStream;
+ friend class java::io::ObjectInputStream;
+ friend class java::io::ObjectStreamClass;
friend void _Jv_WaitForState (jclass, int);
friend void _Jv_RegisterClasses (jclass *classes);
+ friend void _Jv_RegisterClassHookDefault (jclass klass);
friend void _Jv_RegisterInitiatingLoader (jclass,java::lang::ClassLoader*);
friend void _Jv_UnregisterClass (jclass);
friend jclass _Jv_FindClass (_Jv_Utf8Const *name,
java::lang::ClassLoader *loader);
friend jclass _Jv_FindClassInCache (_Jv_Utf8Const *name,
java::lang::ClassLoader *loader);
- friend jclass _Jv_FindArrayClass (jclass element,
- java::lang::ClassLoader *loader);
+ friend jclass _Jv_PopClass (void);
+ friend void _Jv_PushClass (jclass k);
+ friend void _Jv_NewArrayClass (jclass element,
+ java::lang::ClassLoader *loader,
+ _Jv_VTable *array_vtable = 0);
friend jclass _Jv_NewClass (_Jv_Utf8Const *name, jclass superclass,
java::lang::ClassLoader *loader);
+ friend void _Jv_InitNewClassFields (jclass klass);
+
+ // in prims.cc
+ friend void _Jv_InitPrimClass (jclass, char *, char, int, _Jv_ArrayVTable *);
friend void _Jv_PrepareCompiledClass (jclass);
+ friend void _Jv_PrepareConstantTimeTables (jclass);
+ friend jshort _Jv_GetInterfaces (jclass, _Jv_ifaces *);
+ friend void _Jv_GenerateITable (jclass, _Jv_ifaces *, jshort *);
+ friend jstring _Jv_GetMethodString(jclass, _Jv_Utf8Const *);
+ friend jshort _Jv_AppendPartialITable (jclass, jclass, void **, jshort);
+ friend jshort _Jv_FindIIndex (jclass *, jshort *, jshort);
+ friend void _Jv_LinkSymbolTable (jclass);
+ friend void _Jv_LayoutVTableMethods (jclass klass);
+ friend void _Jv_SetVTableEntries (jclass, _Jv_VTable *, jboolean *);
+ friend void _Jv_MakeVTable (jclass);
+
+ friend jboolean _Jv_CheckAccess (jclass self_klass, jclass other_klass,
+ jint flags);
+
+ // Return array class corresponding to element type KLASS, creating it if
+ // necessary.
+ inline friend jclass
+ _Jv_GetArrayClass (jclass klass, java::lang::ClassLoader *loader)
+ {
+ extern void _Jv_NewArrayClass (jclass element,
+ java::lang::ClassLoader *loader,
+ _Jv_VTable *array_vtable = 0);
+ if (__builtin_expect (!klass->arrayclass, false))
+ _Jv_NewArrayClass (klass, loader);
+ return klass->arrayclass;
+ }
#ifdef INTERPRETER
friend jboolean _Jv_IsInterpretedClass (jclass);
friend void _Jv_InitField (jobject, jclass, _Jv_Field*);
- friend int _Jv_DetermineVTableIndex (jclass, _Jv_Utf8Const *,
- _Jv_Utf8Const*);
friend void _Jv_InitField (jobject, jclass, int);
friend _Jv_word _Jv_ResolvePoolEntry (jclass, int);
+ friend _Jv_Method *_Jv_SearchMethodInClass (jclass cls, jclass klass,
+ _Jv_Utf8Const *method_name,
+ _Jv_Utf8Const *method_signature);
+
friend void _Jv_PrepareClass (jclass);
+ friend void _Jv_PrepareMissingMethods (jclass base, jclass iface_class);
friend class _Jv_ClassReader;
friend class _Jv_InterpClass;
friend class _Jv_InterpMethod;
- friend class _Jv_InterpMethodInvocation;
#endif
#ifdef JV_MARKOBJ_DECL
friend JV_MARKOBJ_DECL;
#endif
+ friend class _Jv_BytecodeVerifier;
+ friend class gnu::gcj::runtime::StackTrace;
+ friend class java::io::VMObjectStreamClass;
+
+ friend void _Jv_sharedlib_register_hook (jclass klass);
+
// Chain for class pool.
jclass next;
// Name of class.
// Class constants.
_Jv_Constants constants;
// Methods. If this is an array class, then this field holds a
- // pointer to the element type. If this is a primitive class, this
- // is used to cache a pointer to the appropriate array type.
+ // pointer to the element type.
_Jv_Method *methods;
// Number of methods. If this class is primitive, this holds the
// character used to represent this type in a signature.
jshort static_field_count;
// The vtbl for all objects of this class.
_Jv_VTable *vtable;
+ // Virtual method offset table.
+ _Jv_OffsetTable *otable;
+ // Offset table symbols.
+ _Jv_MethodSymbol *otable_syms;
+ _Jv_AddressTable *atable;
+ _Jv_MethodSymbol *atable_syms;
// Interfaces implemented by this class.
jclass *interfaces;
// The class loader for this class.
// The thread which has locked this class. Used during class
// initialization.
java::lang::Thread *thread;
+ // How many levels of "extends" this class is removed from Object.
+ jshort depth;
+ // Vector of this class's superclasses, ordered by decreasing depth.
+ jclass *ancestors;
+ // Interface Dispatch Table.
+ _Jv_IDispatchTable *idt;
+ // Pointer to the class that represents an array of this class.
+ jclass arrayclass;
+ // Security Domain to which this class belongs (or null).
+ java::security::ProtectionDomain *protectionDomain;
+ // Signers of this class (or null).
+ JArray<jobject> *signers;
+ // Used by Jv_PopClass and _Jv_PushClass to communicate with StackTrace.
+ jclass chain;
};
#endif /* __JAVA_LANG_CLASS_H__ */
projects / gcc.git / blobdiff