OSDN Git Service

2007-04-02 Andrew Haley <aph@redhat.com>
[pf3gnuchains/gcc-fork.git] / libjava / java / lang / Class.h
1 // Class.h - Header file for java.lang.Class.  -*- c++ -*-
2
3 /* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007  Free Software Foundation
4
5    This file is part of libgcj.
6
7 This software is copyrighted work licensed under the terms of the
8 Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
9 details.  */
10
11 // Written primary using compiler source and Class.java as guides.
12 #ifndef __JAVA_LANG_CLASS_H__
13 #define __JAVA_LANG_CLASS_H__
14
15 #pragma interface
16
17 #include <stddef.h>
18 #include <java/lang/Object.h>
19 #include <java/lang/String.h>
20 #include <java/net/URL.h>
21 #include <java/lang/reflect/Modifier.h>
22 #include <java/security/ProtectionDomain.h>
23 #include <java/lang/Package.h>
24
25 // Avoid including SystemClassLoader.h.
26 extern "Java"
27 {
28   namespace gnu
29   {
30     namespace gcj
31     {
32       namespace runtime
33       {
34         class SystemClassLoader;
35       }
36     }
37   }
38 }
39
40 // We declare these here to avoid including gcj/cni.h.
41 extern "C" void _Jv_InitClass (jclass klass);
42 extern "C" jclass _Jv_NewClassFromInitializer 
43    (const char *class_initializer);
44 extern "C" void _Jv_RegisterNewClasses (char **classes);
45 extern "C" void _Jv_RegisterClasses (const jclass *classes);
46 extern "C" void _Jv_RegisterClasses_Counted (const jclass *classes,
47                                              size_t count);
48
49 // This must be predefined with "C" linkage.
50 extern "C" void *_Jv_LookupInterfaceMethodIdx (jclass klass, jclass iface, 
51                                                int meth_idx);
52 extern "C" void *_Jv_ResolvePoolEntry (jclass this_class, jint index);
53
54 // These are the possible values for the `state' field of the class
55 // structure.  Note that ordering is important here.  Whenever the
56 // state changes, one should notify all waiters of this class.
57 enum
58 {
59   JV_STATE_NOTHING = 0,         // Set by compiler.
60
61   JV_STATE_PRELOADING = 1,      // Can do _Jv_FindClass.
62
63   // There is an invariant through libgcj that a class will always be
64   // at a state greater than or equal to JV_STATE_LOADING when it is
65   // returned by a class loader to user code.  Hence, defineclass.cc
66   // installs supers before returning a class, C++-ABI-compiled
67   // classes are created with supers installed, and BC-ABI-compiled
68   // classes are linked to this state before being returned by their
69   // class loader.
70   JV_STATE_LOADING = 3,         // Has super installed.
71   JV_STATE_READ = 4,            // Has been completely defined.
72   JV_STATE_LOADED = 5,          // Has Miranda methods defined.
73
74   JV_STATE_COMPILED = 6,        // This was a compiled class.
75
76   JV_STATE_PREPARED = 7,        // Layout & static init done.
77   JV_STATE_LINKED = 9,          // Strings interned.
78
79   JV_STATE_IN_PROGRESS = 10,    // <clinit> running.
80
81   JV_STATE_ERROR = 12,
82
83   JV_STATE_PHANTOM = 13,        // Bytecode is missing. In many cases we can
84                                 // work around that. If not, throw a
85                                 // NoClassDefFoundError.
86
87   JV_STATE_DONE = 14,           // Must be last.
88
89
90 };
91
92 struct _Jv_Field;
93 struct _Jv_VTable;
94 union _Jv_word;
95 struct _Jv_ArrayVTable;
96 class _Jv_Linker;
97 class _Jv_ExecutionEngine;
98 class _Jv_CompiledEngine;
99 class _Jv_IndirectCompiledEngine;
100 class _Jv_InterpreterEngine;
101
102 #ifdef INTERPRETER
103 class _Jv_ClassReader;
104 class _Jv_InterpClass;
105 class _Jv_InterpMethod;
106 #endif
107
108 class _Jv_ClosureList
109 {
110   _Jv_ClosureList *next;
111   void *ptr;
112 public:
113   void registerClosure (jclass klass, void *ptr);
114   static void releaseClosures (_Jv_ClosureList **closures);
115 };
116
117 struct _Jv_Constants
118 {
119   jint size;
120   jbyte *tags;
121   _Jv_word *data;
122 };
123
124 struct _Jv_Method
125 {
126   // Method name.
127   _Jv_Utf8Const *name;
128   // Method signature.
129   _Jv_Utf8Const *signature;
130   // Access flags.
131   _Jv_ushort accflags;
132   // Method's index in the vtable.
133   _Jv_ushort index;
134   // Pointer to underlying function.
135   void *ncode;
136   // NULL-terminated list of exception class names; can be NULL if
137   // there are none such.
138   _Jv_Utf8Const **throws;
139
140   _Jv_Method *getNextMethod ()
141   { return this + 1; }
142 };
143
144 // The table used to resolve interface calls.
145 struct _Jv_IDispatchTable
146 {
147   // Index into interface's ioffsets.
148   jshort iindex;
149   jshort itable_length;
150   // Class Interface dispatch table.
151   void *itable[0];
152 };
153
154 // Used by _Jv_Linker::get_interfaces ()
155 struct _Jv_ifaces
156 {
157   jclass *list;
158   jshort len;
159   jshort count;
160 };
161
162 struct _Jv_MethodSymbol
163 {
164   _Jv_Utf8Const *class_name;
165   _Jv_Utf8Const *name;
166   _Jv_Utf8Const *signature;
167 };
168
169 struct _Jv_OffsetTable
170 {
171   jint state;
172   jint offsets[];
173 };
174
175 struct _Jv_AddressTable
176 {
177   jint state;
178   void *addresses[];
179 };
180
181 struct _Jv_CatchClass
182 {
183   java::lang::Class **address;
184   _Jv_Utf8Const *classname;
185 };
186
187 // Possible values for the assertion_code field in the type assertion table.
188 enum
189 {
190   JV_ASSERT_END_OF_TABLE = 0,
191   JV_ASSERT_TYPES_COMPATIBLE = 1,
192   JV_ASSERT_IS_INSTANTIABLE = 2
193 };
194
195 // Entry in the type assertion table, used to validate type constraints
196 // for binary compatibility.
197 struct _Jv_TypeAssertion
198 {
199   jint assertion_code;
200   _Jv_Utf8Const *op1;
201   _Jv_Utf8Const *op2;
202 };
203
204 typedef enum
205 {
206   JV_CLASS_ATTR,
207   JV_METHOD_ATTR,
208   JV_FIELD_ATTR,
209   JV_DONE_ATTR
210 } jv_attr_type;
211
212 typedef enum
213 {
214   JV_INNER_CLASSES_KIND,
215   JV_ENCLOSING_METHOD_KIND,
216   JV_SIGNATURE_KIND,
217   JV_ANNOTATIONS_KIND,
218   JV_PARAMETER_ANNOTATIONS_KIND,
219   JV_ANNOTATION_DEFAULT_KIND
220 } jv_attr_kind;
221
222 #define JV_PRIMITIVE_VTABLE ((_Jv_VTable *) -1)
223
224 #define JV_CLASS(Obj) ((jclass) (*(_Jv_VTable **) Obj)->clas)
225
226 // Forward declarations for friends of java::lang::Class
227
228 // Friend functions implemented in natClass.cc.
229 _Jv_Method *_Jv_GetMethodLocal (jclass klass, _Jv_Utf8Const *name,
230                                 _Jv_Utf8Const *signature);
231 jboolean _Jv_IsAssignableFrom (jclass, jclass);
232 jboolean _Jv_IsAssignableFromSlow (jclass, jclass);
233 jboolean _Jv_InterfaceAssignableFrom (jclass, jclass);
234
235 _Jv_Method* _Jv_LookupDeclaredMethod (jclass, _Jv_Utf8Const *, 
236                                       _Jv_Utf8Const*, jclass * = NULL);
237 java::lang::reflect::Method *_Jv_GetReflectedMethod (jclass klass, 
238                                                     _Jv_Utf8Const *name,
239                                                     _Jv_Utf8Const *signature);
240 java::lang::reflect::Method *_Jv_LookupProxyMethod (jclass, _Jv_Utf8Const *,
241                                                     _Jv_Utf8Const *);
242 jfieldID JvGetFirstInstanceField (jclass);
243 jint JvNumInstanceFields (jclass);
244 jfieldID JvGetFirstStaticField (jclass);
245 jint JvNumStaticFields (jclass);
246
247 jobject _Jv_AllocObject (jclass);
248 void *_Jv_AllocObj (jint, jclass);
249 void *_Jv_AllocPtrFreeObj (jint, jclass);
250 void *_Jv_AllocArray (jint, jclass);
251
252 bool _Jv_getInterfaceMethod(jclass, jclass&, int&, 
253                             const _Jv_Utf8Const*,
254                             const _Jv_Utf8Const*);
255
256 jobject _Jv_JNI_ToReflectedField (_Jv_JNIEnv *, jclass, jfieldID,
257                                   jboolean);
258 jobject _Jv_JNI_ToReflectedMethod (_Jv_JNIEnv *, jclass, jmethodID,
259                                    jboolean);
260 jfieldID _Jv_FromReflectedField (java::lang::reflect::Field *);
261
262 jmethodID _Jv_FromReflectedMethod (java::lang::reflect::Method *);
263 jmethodID _Jv_FromReflectedConstructor (java::lang::reflect::Constructor *);
264 jint JvNumMethods (jclass);
265 jmethodID JvGetFirstMethod (jclass);
266 _Jv_Utf8Const *_Jv_GetClassNameUtf8 (jclass);
267
268 #ifdef INTERPRETER
269 // Finds a desired interpreter method in the given class or NULL if not found
270 class _Jv_MethodBase;
271 _Jv_MethodBase *_Jv_FindInterpreterMethod (jclass, jmethodID);
272 jstring _Jv_GetInterpClassSourceFile (jclass);
273 #endif
274
275 jbyte _Jv_GetClassState (jclass);
276
277 // Friend classes and functions to implement the ClassLoader
278 class java::lang::ClassLoader;
279 class java::lang::VMClassLoader;
280
281 class java::io::ObjectOutputStream;
282 class java::io::ObjectInputStream;
283 class java::io::ObjectStreamClass;
284
285 void _Jv_RegisterClassHookDefault (jclass klass);
286 void _Jv_RegisterInitiatingLoader (jclass,java::lang::ClassLoader*);
287 void _Jv_UnregisterInitiatingLoader (jclass,java::lang::ClassLoader*);
288 void _Jv_UnregisterClass (jclass);
289 jclass _Jv_FindClassNoException (_Jv_Utf8Const *name,
290                       java::lang::ClassLoader *loader);
291 jclass _Jv_FindClass (_Jv_Utf8Const *name,
292                       java::lang::ClassLoader *loader);
293 jclass _Jv_FindClassInCache (_Jv_Utf8Const *name);
294 jclass _Jv_PopClass (void);
295 void _Jv_PushClass (jclass k);
296 void _Jv_NewArrayClass (jclass element,
297                         java::lang::ClassLoader *loader,
298                         _Jv_VTable *array_vtable = 0);
299 jclass _Jv_NewClass (_Jv_Utf8Const *name, jclass superclass,
300                      java::lang::ClassLoader *loader);
301 void _Jv_InitNewClassFields (jclass klass);
302
303 // Friend functions and classes in prims.cc
304 void _Jv_InitPrimClass (jclass, const char *, char, int);
305 jstring _Jv_GetMethodString (jclass, _Jv_Method *, jclass = NULL);
306
307 jboolean _Jv_CheckAccess (jclass self_klass, jclass other_klass,
308                           jint flags);
309 jclass _Jv_GetArrayClass (jclass klass, java::lang::ClassLoader *loader);
310
311 jboolean _Jv_IsInterpretedClass (jclass);
312 jboolean _Jv_IsBinaryCompatibilityABI (jclass);
313
314 jboolean _Jv_IsPhantomClass (jclass);
315
316 void _Jv_CopyClassesToSystemLoader (gnu::gcj::runtime::SystemClassLoader *);
317
318 #ifdef INTERPRETER
319 void _Jv_InitField (jobject, jclass, int);
320 #endif
321
322 class _Jv_StackTrace;
323 class _Jv_BytecodeVerifier;
324 class java::io::VMObjectStreamClass;
325
326 void _Jv_sharedlib_register_hook (jclass klass);
327
328 /* Find the class that defines the given method. Returns NULL
329    if it cannot be found. Searches both interpreted and native
330    classes. */
331 jclass _Jv_GetMethodDeclaringClass (jmethodID method);
332
333 class java::lang::Class : public java::lang::Object
334 {
335 public:
336   static jclass forName (jstring className, jboolean initialize, 
337                          java::lang::ClassLoader *loader);
338   static jclass forName (jstring className);
339   JArray<jclass> *getClasses (void);
340
341   java::lang::ClassLoader *getClassLoader (void);
342 private:
343   java::lang::ClassLoader *getClassLoader (jclass caller);
344 public:
345   // This is an internal method that circumvents the usual security
346   // checks when getting the class loader.
347   java::lang::ClassLoader *getClassLoaderInternal (void)
348   {
349     return loader;
350   }
351
352   java::lang::reflect::Constructor *getConstructor (JArray<jclass> *);
353   JArray<java::lang::reflect::Constructor *> *getConstructors (void);
354   java::lang::reflect::Constructor *getDeclaredConstructor (JArray<jclass> *);
355   JArray<java::lang::reflect::Constructor *> *getDeclaredConstructors (jboolean);
356   java::lang::reflect::Field *getDeclaredField (jstring);
357   JArray<java::lang::reflect::Field *> *getDeclaredFields ();
358   JArray<java::lang::reflect::Field *> *getDeclaredFields (jboolean);
359   java::lang::reflect::Method *getDeclaredMethod (jstring, JArray<jclass> *);
360   JArray<java::lang::reflect::Method *> *getDeclaredMethods (void);
361
362   JArray<jclass> *getDeclaredClasses (void);
363   JArray<jclass> *getDeclaredClasses (jboolean);
364   jclass getDeclaringClass (void);
365
366   java::lang::reflect::Field *getField (jstring);
367 private:
368   JArray<java::lang::reflect::Field *> internalGetFields ();
369   java::lang::reflect::Field *getField (jstring, jint);
370   jint _getMethods (JArray<java::lang::reflect::Method *> *result,
371                     jint offset);
372   java::lang::reflect::Field *getPrivateField (jstring);
373   java::lang::reflect::Method *getPrivateMethod (jstring, JArray<jclass> *);
374   java::security::ProtectionDomain *getProtectionDomain0 ();
375
376   java::lang::reflect::Method *_getMethod (jstring, JArray<jclass> *);
377   java::lang::reflect::Method *_getDeclaredMethod (jstring, JArray<jclass> *);
378
379   jstring getReflectionSignature (jint /*jv_attr_type*/ type,
380                                   jint obj_index);
381   jstring getReflectionSignature (::java::lang::reflect::Method *);
382   jstring getReflectionSignature (::java::lang::reflect::Constructor *);
383   jstring getReflectionSignature (::java::lang::reflect::Field *);
384
385   jstring getClassSignature();
386   jobject getMethodDefaultValue (::java::lang::reflect::Method *);
387
388 public:
389   JArray<java::lang::reflect::Field *> *getFields (void);
390
391   JArray<jclass> *getInterfaces (void);
392
393   void getSignature (java::lang::StringBuffer *buffer);
394   static jstring getSignature (JArray<jclass> *, jboolean is_constructor);
395   JArray<java::lang::reflect::Method *> *getMethods (void);
396
397   inline jint getModifiers (void)
398   {
399     return accflags & java::lang::reflect::Modifier::ALL_FLAGS;
400   }
401
402   jstring getName (void);
403
404   java::net::URL        *getResource (jstring resourceName);
405   java::io::InputStream *getResourceAsStream (jstring resourceName);
406   JArray<jobject> *getSigners (void);
407   void setSigners(JArray<jobject> *);
408
409   inline jclass getSuperclass (void)
410   {
411     return superclass;
412   }
413
414   inline jclass getInterface (jint n)
415   {
416     return interfaces[n];
417   }
418
419   inline jboolean isArray (void)
420     {
421       return name->first() == '[';
422     }
423
424   inline jclass getComponentType (void)
425     {
426       return isArray () ? element_type : 0;
427     }
428
429   jboolean isAssignableFrom (jclass cls);
430   jboolean isInstance (jobject obj);
431
432   inline jboolean isInterface (void)
433   {
434     return (accflags & java::lang::reflect::Modifier::INTERFACE) != 0;
435   }
436   
437   inline jboolean isPrimitive (void)
438     {
439       return vtable == JV_PRIMITIVE_VTABLE;
440     }
441
442   jobject newInstance (void);
443   java::security::ProtectionDomain *getProtectionDomain (void);
444   java::lang::Package *getPackage (void);
445   jstring toString (void);
446   jboolean desiredAssertionStatus (void);
447
448   JArray<java::lang::reflect::TypeVariable *> *getTypeParameters (void);
449
450   jint getEnclosingMethodData(void);
451   java::lang::Class *getEnclosingClass (void);
452   java::lang::reflect::Constructor *getEnclosingConstructor (void);
453   java::lang::reflect::Method *getEnclosingMethod (void);
454   jobjectArray getDeclaredAnnotations(jint, jint, jint);
455   jobjectArray getDeclaredAnnotations(::java::lang::reflect::Method *,
456                                       jboolean);
457   jobjectArray getDeclaredAnnotations(::java::lang::reflect::Constructor *,
458                                       jboolean);
459   jobjectArray getDeclaredAnnotations(::java::lang::reflect::Field *);
460   JArray< ::java::lang::annotation::Annotation *> *getDeclaredAnnotationsInternal();
461
462   jboolean isEnum (void)
463   {
464     return (accflags & 0x4000) != 0;
465   }
466   jboolean isSynthetic (void)
467   {
468     return (accflags & 0x1000) != 0;
469   }
470   jboolean isAnnotation (void)
471   {
472     return (accflags & 0x2000) != 0;
473   }
474
475   jboolean isAnonymousClass();
476   jboolean isLocalClass();
477   jboolean isMemberClass();
478
479   // FIXME: this probably shouldn't be public.
480   jint size (void)
481   {
482     return size_in_bytes;
483   }
484
485   // The index of the first method we declare ourself (as opposed to
486   // inheriting).
487   inline jint firstMethodIndex (void)
488   {
489     return vtable_method_count - method_count;
490   }
491     
492   // finalization
493   void finalize ();
494
495   // This constructor is used to create Class object for the primitive
496   // types. See prims.cc.
497   Class ();
498
499   // Given the BC ABI version, return the size of an Class initializer.
500   static jlong initializerSize (jlong ABI)
501   {
502     unsigned long version = ABI & 0xfffff;
503     int abi_rev = version % 100;
504     
505     // The reflection_data field was added by abi_rev 1.
506     if (abi_rev == 0)
507       return ((char*)(&::java::lang::Class::class$.reflection_data)
508               - (char*)&::java::lang::Class::class$);
509     
510     return sizeof (::java::lang::Class);
511   }
512
513   static java::lang::Class class$;
514
515 private:   
516
517   void memberAccessCheck (jint flags);
518
519   void initializeClass (void);
520
521   static jstring getPackagePortion (jstring);
522
523   void set_state (jint nstate)
524   {
525     state = nstate;
526     notifyAll ();
527   }
528
529   jint findInnerClassAttribute();
530   jint findDeclaredClasses(JArray<jclass> *, jboolean, jint);
531
532   // Friend functions implemented in natClass.cc.
533   friend _Jv_Method *::_Jv_GetMethodLocal (jclass klass, _Jv_Utf8Const *name,
534                                            _Jv_Utf8Const *signature);
535   friend jboolean (::_Jv_IsAssignableFrom) (jclass, jclass);
536   friend jboolean (::_Jv_IsAssignableFromSlow) (jclass, jclass);
537   friend jboolean (::_Jv_InterfaceAssignableFrom) (jclass, jclass);
538   friend void *::_Jv_LookupInterfaceMethodIdx (jclass klass, jclass iface, 
539                                                int method_idx);
540
541   friend void ::_Jv_InitClass (jclass klass);
542   friend java::lang::Class* ::_Jv_NewClassFromInitializer (const char *class_initializer);
543   friend void _Jv_RegisterNewClasses (void **classes);
544
545   friend _Jv_Method* ::_Jv_LookupDeclaredMethod (jclass, _Jv_Utf8Const *, 
546                                                  _Jv_Utf8Const*, jclass *);
547   friend java::lang::reflect::Method* ::_Jv_GetReflectedMethod (jclass klass, 
548                                                     _Jv_Utf8Const *name,
549                                                     _Jv_Utf8Const *signature);
550   friend java::lang::reflect::Method *::_Jv_LookupProxyMethod (jclass, _Jv_Utf8Const *,
551                                                                _Jv_Utf8Const *);
552
553   friend jfieldID (::JvGetFirstInstanceField) (jclass);
554   friend jint (::JvNumInstanceFields) (jclass);
555   friend jfieldID (::JvGetFirstStaticField) (jclass);
556   friend jint (::JvNumStaticFields) (jclass);
557
558   friend jobject (::_Jv_AllocObject) (jclass);
559   friend void *::_Jv_AllocObj (jint, jclass);
560   friend void *::_Jv_AllocPtrFreeObj (jint, jclass);
561   friend void *::_Jv_AllocArray (jint, jclass);
562
563   friend jobject (::_Jv_JNI_ToReflectedField) (_Jv_JNIEnv *, jclass, jfieldID,
564                                                jboolean);
565   friend jobject (::_Jv_JNI_ToReflectedMethod) (_Jv_JNIEnv *, jclass, jmethodID,
566                                                 jboolean);
567   friend jfieldID (::_Jv_FromReflectedField) (java::lang::reflect::Field *);
568
569   friend jmethodID (::_Jv_FromReflectedMethod) (java::lang::reflect::Method *);
570   friend jmethodID (::_Jv_FromReflectedConstructor) (java::lang::reflect::Constructor *);
571   friend jint (::JvNumMethods) (jclass);
572   friend jmethodID (::JvGetFirstMethod) (jclass);
573   friend _Jv_Utf8Const *::_Jv_GetClassNameUtf8 (jclass);
574 #ifdef INTERPRETER
575   friend _Jv_MethodBase *(::_Jv_FindInterpreterMethod) (jclass klass,
576                                                         jmethodID desired_method);
577   friend jstring ::_Jv_GetInterpClassSourceFile (jclass);
578 #endif
579   friend jbyte (::_Jv_GetClassState) (jclass klass);
580
581   // Friends classes and functions to implement the ClassLoader
582   friend class java::lang::ClassLoader;
583   friend class java::lang::VMClassLoader;
584
585   friend class java::io::ObjectOutputStream;
586   friend class java::io::ObjectInputStream;
587   friend class java::io::ObjectStreamClass;
588
589   friend void ::_Jv_RegisterClasses (const jclass *classes);
590   friend void ::_Jv_RegisterClasses_Counted (const jclass *classes, 
591                                              size_t count);
592   friend void ::_Jv_RegisterClassHookDefault (jclass klass);
593   friend void ::_Jv_RegisterInitiatingLoader (jclass,java::lang::ClassLoader*);
594   friend void ::_Jv_UnregisterInitiatingLoader (jclass,java::lang::ClassLoader*);
595   friend void ::_Jv_UnregisterClass (jclass);
596   friend jclass (::_Jv_FindClassNoException) (_Jv_Utf8Const *name,
597                                    java::lang::ClassLoader *loader);
598   friend jclass (::_Jv_FindClass) (_Jv_Utf8Const *name,
599                                    java::lang::ClassLoader *loader);
600   friend jclass (::_Jv_FindClassInCache) (_Jv_Utf8Const *name);
601   friend jclass (::_Jv_PopClass) (void);
602   friend void ::_Jv_PushClass (jclass k);
603   friend void ::_Jv_NewArrayClass (jclass element,
604                                    java::lang::ClassLoader *loader,
605                                    _Jv_VTable *array_vtable);
606   friend jclass (::_Jv_NewClass) (_Jv_Utf8Const *name, jclass superclass,
607                                   java::lang::ClassLoader *loader);
608   friend void ::_Jv_InitNewClassFields (jclass klass);
609
610   // in prims.cc
611   friend void ::_Jv_InitPrimClass (jclass, const char *, char, int);
612
613   friend jstring (::_Jv_GetMethodString) (jclass, _Jv_Method *, jclass);
614
615   friend jboolean (::_Jv_CheckAccess) (jclass self_klass, jclass other_klass,
616                                    jint flags);
617   
618   friend bool (::_Jv_getInterfaceMethod) (jclass, jclass&, int&, 
619                                           const _Jv_Utf8Const*,
620                                           const _Jv_Utf8Const*);
621
622   friend jclass (::_Jv_GetArrayClass) (jclass klass,
623                                        java::lang::ClassLoader *loader);
624
625   friend jboolean (::_Jv_IsInterpretedClass) (jclass);
626   friend jboolean (::_Jv_IsBinaryCompatibilityABI) (jclass);
627
628   friend jboolean (::_Jv_IsPhantomClass) (jclass);
629
630 #ifdef INTERPRETER
631   friend void ::_Jv_InitField (jobject, jclass, int);
632
633   friend class ::_Jv_ClassReader;       
634   friend class ::_Jv_InterpClass;
635   friend class ::_Jv_InterpMethod;
636 #endif
637   friend class ::_Jv_StackTrace;
638
639 #ifdef JV_MARKOBJ_DECL
640   friend JV_MARKOBJ_DECL;
641 #endif
642
643   friend class ::_Jv_BytecodeVerifier;
644   friend class java::io::VMObjectStreamClass;
645
646   friend class ::_Jv_Linker;
647   friend class ::_Jv_ExecutionEngine;
648   friend class ::_Jv_CompiledEngine;
649   friend class ::_Jv_IndirectCompiledEngine;
650   friend class ::_Jv_InterpreterEngine;
651   friend class ::_Jv_ClosureList;
652
653   friend void ::_Jv_sharedlib_register_hook (jclass klass);
654
655   friend void *::_Jv_ResolvePoolEntry (jclass this_class, jint index);
656
657   friend void ::_Jv_CopyClassesToSystemLoader (gnu::gcj::runtime::SystemClassLoader *);
658
659   friend class java::lang::reflect::Field;
660   friend class java::lang::reflect::Method;
661   friend class java::lang::reflect::Constructor;
662   friend class java::lang::reflect::VMProxy;
663
664   // Chain for class pool.  This also doubles as the ABI version
665   // number.  It is only used for this purpose at class registration
666   // time, and only for precompiled classes.
667   jclass next_or_version;
668   // Name of class.
669   _Jv_Utf8Const *name;
670   // Access flags for class.
671   _Jv_ushort accflags;
672   // The superclass, or null for Object.
673   jclass superclass;
674   // Class constants.
675   _Jv_Constants constants;
676   // Methods.  If this is an array class, then this field holds a
677   // pointer to the element type.
678   union
679   {
680     _Jv_Method *methods;
681     jclass element_type;
682   };
683   // Number of methods.  If this class is primitive, this holds the
684   // character used to represent this type in a signature.
685   jshort method_count;
686   // Number of methods in the vtable.
687   jshort vtable_method_count;
688   // The fields.
689   _Jv_Field *fields;
690   // Size of instance fields, in bytes.
691   jint size_in_bytes;
692   // Total number of fields (instance and static).
693   jshort field_count;
694   // Number of static fields.
695   jshort static_field_count;
696   // The vtbl for all objects of this class.
697   _Jv_VTable *vtable;
698   // Virtual method offset table.
699   _Jv_OffsetTable *otable;
700   // Offset table symbols.
701   _Jv_MethodSymbol *otable_syms;
702   // Address table
703   _Jv_AddressTable *atable;
704   _Jv_MethodSymbol *atable_syms;
705   // Interface table
706   _Jv_AddressTable *itable;
707   _Jv_MethodSymbol *itable_syms;
708   _Jv_CatchClass *catch_classes;
709   // Interfaces implemented by this class.
710   jclass *interfaces;
711   // The class loader for this class.
712   java::lang::ClassLoader *loader;
713   // Number of interfaces.
714   jshort interface_count;
715   // State of this class.
716   jbyte state;
717   // The thread which has locked this class.  Used during class
718   // initialization.
719   java::lang::Thread *thread;
720   // How many levels of "extends" this class is removed from Object.
721   jshort depth;
722   // Vector of this class's superclasses, ordered by decreasing depth.
723   jclass *ancestors;
724   // In a regular class, this field points to the Class Interface Dispatch 
725   // Table. In an interface, it points to the ioffsets table.
726   union 
727   {
728     _Jv_IDispatchTable *idt;
729     jshort *ioffsets;
730   };
731   // Pointer to the class that represents an array of this class.
732   jclass arrayclass;
733   // Security Domain to which this class belongs (or null).
734   java::security::ProtectionDomain *protectionDomain;
735   // Pointer to the type assertion table for this class.
736   _Jv_TypeAssertion *assertion_table;
737   // Signers of this class (or null).
738   JArray<jobject> *hack_signers;
739   // Used by Jv_PopClass and _Jv_PushClass to communicate with StackTrace.
740   jclass chain;
741   // Additional data, specific to the generator (JIT, native,
742   // interpreter) of this class.
743   void *aux_info;
744   // Execution engine.
745   _Jv_ExecutionEngine *engine;
746   // Reflection data.
747   unsigned char *reflection_data;
748 };
749
750 // Inline functions that are friends of java::lang::Class
751
752 inline void _Jv_InitClass (jclass klass)
753 {
754   if (__builtin_expect (klass->state == JV_STATE_DONE, true))
755     return;
756   klass->initializeClass ();  
757 }
758
759 // Return array class corresponding to element type KLASS, creating it if
760 // necessary.
761 inline jclass
762 _Jv_GetArrayClass (jclass klass, java::lang::ClassLoader *loader)
763 {
764   extern void _Jv_NewArrayClass (jclass element,
765                                  java::lang::ClassLoader *loader,
766                                  _Jv_VTable *array_vtable = 0);
767   if (__builtin_expect (!klass->arrayclass, false))
768     _Jv_NewArrayClass (klass, loader);
769   return klass->arrayclass;
770 }
771
772 #endif /* __JAVA_LANG_CLASS_H__ */