1) fix for getDeclaredClass(publiconly=true) returning protected classes
[cacao.git] / src / native / vm / VMClass.c
1 /* class: java/lang/Class */
2
3
4 #include "jni.h"
5 #include "types.h"
6 #include "global.h"
7 #include "builtin.h"
8 #include "loader.h"
9 #include "native.h"
10 #include "tables.h"
11 #include "java_lang_Class.h"
12 #include "java_lang_reflect_Constructor.h"
13 #include "java_lang_reflect_Field.h"
14 #include "java_lang_reflect_Method.h"
15 #include "java_lang_Throwable.h"    /* needed for java_lang_VMClass.h */
16 #include "java_lang_VMClass.h"
17
18
19 /* for selecting public members */
20 #define MEMBER_PUBLIC  0
21
22
23 /*
24  * Class:     java_lang_VMClass
25  * Method:    forName
26  * Signature: (Ljava/lang/String;)Ljava/lang/Class;
27  */
28 JNIEXPORT struct java_lang_Class* JNICALL Java_java_lang_VMClass_forName(JNIEnv *env, jclass clazz, struct java_lang_String* s)
29 {
30         classinfo *c;
31         utf *u;
32
33         if (runverbose) {
34             log_text("Java_java_lang_VMClass_forName called");
35             log_text(javastring_tochar((java_objectheader*)s));
36         }
37
38         /* illegal argument */
39         if (!s) return NULL;
40         
41         /* create utf string in which '.' is replaced by '/' */
42         u = javastring_toutf(s, true);
43         
44             c = loader_load(u);
45             if (c == NULL) {
46                 /* class was not loaded. raise exception */
47                 if (! exceptionptr) {
48                         if (runverbose)
49                                 log_text("Setting class not found exception");
50                         exceptionptr = 
51                             native_new_and_init_string(class_java_lang_ClassNotFoundException, s);
52                 }
53             return NULL;
54
55         }
56         /*log_text("Returning class");*/
57         use_class_as_object (c);
58         return (java_lang_Class*) c;
59 }
60
61 /*
62  * Class:     java_lang_VMClass
63  * Method:    getClassLoader
64  * Signature: ()Ljava/lang/ClassLoader;
65  */
66 JNIEXPORT struct java_lang_ClassLoader* JNICALL Java_java_lang_VMClass_getClassLoader (JNIEnv *env ,  struct java_lang_VMClass* this )
67 {  
68   init_systemclassloader();
69   return SystemClassLoader;
70 }
71
72 /*
73  * Class:     java_lang_VMClass
74  * Method:    getModifiers
75  * Signature: ()I
76  */
77 JNIEXPORT struct java_lang_Class* JNICALL Java_java_lang_VMClass_getComponentType (JNIEnv *env ,  struct java_lang_VMClass* this )
78 {
79     classinfo *thisclass = (classinfo*) (this->vmData);
80     classinfo *c = NULL;
81     arraydescriptor *desc;
82     
83     if ((desc = thisclass->vftbl->arraydesc) != NULL) {
84         if (desc->arraytype == ARRAYTYPE_OBJECT)
85             c = desc->componentvftbl->class;
86         else
87             c = primitivetype_table[desc->arraytype].class_primitive;
88         
89         /* set vftbl */
90         use_class_as_object (c);
91     }
92     
93     return (java_lang_Class*) c;
94 }
95
96
97 /*
98  * Class:     java_lang_VMClass
99  * Method:    getDeclaredConstructors
100  * Signature: (Z)[Ljava/lang/reflect/Constructor;
101  */
102 JNIEXPORT java_objectarray* JNICALL Java_java_lang_VMClass_getDeclaredConstructors (JNIEnv *env ,  struct java_lang_VMClass* this , s4 public_only)
103 {
104   
105     classinfo *c = (classinfo *) (this->vmData);
106     java_objectheader *o;
107     classinfo *class_constructor;
108     java_objectarray *array_constructor;     /* result: array of Method-objects */
109     java_objectarray *exceptiontypes;   /* the exceptions thrown by the method */
110     methodinfo *m;                      /* the current method to be represented */    
111     int public_methods = 0;             /* number of public methods of the class */
112     int pos = 0;
113     int i;
114     utf *utf_constr=utf_new_char("<init>");
115
116
117     
118    log_text("Java_java_lang_VMClass_getDeclaredConstructors");
119     utf_display(c->name);
120     printf("\n");
121 /*    class_showmethods(c);
122     class_showmethods(loader_load(utf_new_char("java/lang/Class")));*/
123
124
125     /* determine number of constructors */
126     for (i = 0; i < c->methodscount; i++) 
127         if ((((c->methods[i].flags & ACC_PUBLIC)) || (!public_only)) && 
128                 (c->methods[i].name==utf_constr)) public_methods++;
129
130     class_constructor = (classinfo*) loader_load(utf_new_char ("java/lang/reflect/Constructor"));
131     if (!class_constructor) 
132         return NULL;
133
134
135     array_constructor = builtin_anewarray(public_methods, class_constructor);
136
137     if (!array_constructor) 
138         return NULL;
139
140     for (i = 0; i < c->methodscount; i++) 
141         if ((c->methods[i].flags & ACC_PUBLIC) || (!public_only)){
142         
143             m = &c->methods[i];     
144             if (m->name!=utf_constr) continue;
145             o = native_new_and_init(class_constructor);     
146             array_constructor->data[pos++] = o;
147
148             /* array of exceptions declared to be thrown, information not available !! */
149             exceptiontypes = builtin_anewarray (0, class_java_lang_Class);
150
151 /*          class_showconstantpool(class_constructor);*/
152             /* initialize instance fields */
153 /*          ((java_lang_reflect_Constructor*)o)->flag=(m->flags & (ACC_PRIVATE | ACC_PUBLIC | ACC_PROTECTED));*/
154             setfield_critical(class_constructor,o,"clazz",          "Ljava/lang/Class;",  jobject, (jobject) c /*this*/);
155             setfield_critical(class_constructor,o,"slot",           "I",                     jint,    i); 
156 /*          setfield_critical(class_constructor,o,"flag",           "I",                     jint,    (m->flags & (ACC_PRIVATE | 
157                         ACC_PUBLIC | ACC_PROTECTED))); */
158             setfield_critical(class_constructor,o,"exceptionTypes", "[Ljava/lang/Class;", jobject, (jobject) exceptiontypes);
159             setfield_critical(class_constructor,o,"parameterTypes", "[Ljava/lang/Class;", jobject, (jobject) get_parametertypes(m));
160         }            
161     
162 log_text("leaving Java_java_lang_VMClass_getDeclaredConstructors");
163 return array_constructor;
164
165
166
167
168 /*  panic("Java_java_lang_Class_getConstructors0 called");
169   return NULL;*/
170 }
171
172
173 /*
174  * Class:     java_lang_VMClass
175  * Method:    getDeclaredClasses
176  * Signature: (Z)[Ljava/lang/Class;
177  */
178 JNIEXPORT java_objectarray* JNICALL Java_java_lang_VMClass_getDeclaredClasses (JNIEnv *env ,  struct java_lang_VMClass* this , s4 publicOnly)
179 {
180 #warning fix the public only case
181   classinfo *c = (classinfo *) (this->vmData);
182   int pos = 0;                /* current declared class */
183   int declaredclasscount = 0; /* number of declared classes */
184   java_objectarray *result;   /* array of declared classes */
185   int notPublicOnly=!publicOnly;
186   int i;
187
188   if (!this)
189     return NULL;
190
191   if (!this->vmData)
192     return NULL;
193
194         /*printf("PublicOnly: %d\n",publicOnly);*/
195   if (!Java_java_lang_VMClass_isPrimitive(env, c) && (c->name->text[0]!='[')) {
196     /* determine number of declared classes */
197     for (i = 0; i < c->innerclasscount; i++) {
198       if ( (c->innerclass[i].outer_class == c) && (notPublicOnly || (c->innerclass[i].flags & ACC_PUBLIC)))
199         /* outer class is this class */
200         declaredclasscount++;
201     }
202   }
203
204   /*class_showmethods(c); */
205
206   result = builtin_anewarray(declaredclasscount, class_java_lang_Class);        
207
208   for (i = 0; i < c->innerclasscount; i++) {
209     
210     classinfo *inner =  c->innerclass[i].inner_class;
211     classinfo *outer =  c->innerclass[i].outer_class;
212
213       
214     if ( (outer == c) && (notPublicOnly || (inner->flags & ACC_PUBLIC))) {
215       /* outer class is this class, store innerclass in array */
216       use_class_as_object (inner);
217       result->data[pos++] = (java_objectheader *) inner;
218     }
219   }
220
221   return result;
222 }
223
224 /*
225  * Class:     java/lang/Class
226  * Method:    getDeclaringClass
227  * Signature: ()Ljava/lang/Class;
228  */
229 JNIEXPORT struct java_lang_Class* JNICALL Java_java_lang_VMClass_getDeclaringClass ( JNIEnv *env ,  struct java_lang_VMClass* this)
230 {
231 #warning fixme
232   classinfo *c = (classinfo *) (this->vmData);
233   log_text("Java_java_lang_VMClass_getDeclaringClass");
234
235   if (this && this->vmData && !Java_java_lang_VMClass_isPrimitive(env, this) && (c->name->text[0]!='[')) {    
236     int i;
237
238     if (c->innerclasscount == 0)  /* no innerclasses exist */
239         return NULL;
240     
241     for (i = 0; i < c->innerclasscount; i++) {
242
243       classinfo *inner =  c->innerclass[i].inner_class;
244       classinfo *outer =  c->innerclass[i].outer_class;
245       
246       if (inner == c) {
247         /* innerclass is this class */
248         use_class_as_object (outer);
249         return (java_lang_Class*) outer;
250       }
251     }
252   }
253
254   /* return NULL for arrayclasses and primitive classes */
255   return NULL;
256 }
257
258 /*
259  * Class:     java/lang/Class
260  * Method:    getField0
261  * Signature: (Ljava/lang/String;I)Ljava/lang/reflect/Field;
262  */
263 JNIEXPORT struct java_lang_reflect_Field* JNICALL Java_java_lang_VMClass_getField0 ( JNIEnv *env ,  struct java_lang_VMClass* this, struct java_lang_String* name, s4 public_only)
264 {
265     classinfo *c, *fieldtype;   
266     fieldinfo *f;               /* the field to be represented */
267     java_lang_reflect_Field *o; /* result: field-object */
268     utf *desc;                  /* the fielddescriptor */
269     int idx;
270
271     /* create Field object */
272     c = (classinfo*) loader_load(utf_new_char ("java/lang/reflect/Field"));
273     o = (java_lang_reflect_Field*) native_new_and_init(c);
274
275     /* get fieldinfo entry */
276     idx = class_findfield_index_approx((classinfo*) (this->vmData), javastring_toutf(name, false));
277     if (idx<0) {
278             exceptionptr = native_new_and_init(class_java_lang_NoSuchFieldException);
279             return NULL;
280         }
281     f= &(((struct classinfo*)(this->vmData))->fields[idx]);
282     if (f) {
283
284         if ( public_only && !(f->flags & ACC_PUBLIC))
285         {
286             /* field is not public  and public only had been requested*/
287             exceptionptr = native_new_and_init(class_java_lang_NoSuchFieldException);
288             return NULL;
289         }
290
291       desc = f->descriptor;
292       fieldtype = class_from_descriptor(desc->text,utf_end(desc),NULL,true);
293       if (!fieldtype) return NULL;
294          
295       /* initialize instance fields */
296       setfield_critical(c,o,"declaringClass",          "Ljava/lang/Class;",  jobject, (jobject) (this->vmData) /*this*/);
297 /*      ((java_lang_reflect_Field*)(o))->flag=f->flags;*/
298       /* save type in slot-field for faster processing */
299 /*      setfield_critical(c,o,"flag",           "I",                jint,    (jint) f->flags);  */
300       setfield_critical(c,o,"slot",           "I",                  jint,    (jint) idx);  
301       setfield_critical(c,o,"name",           "Ljava/lang/String;", jstring, (jstring) name);
302       /*setfield_critical(c,o,"type",           "Ljava/lang/Class;",  jclass,  fieldtype);*/
303
304       return o;
305     }
306
307     return NULL;
308 }
309
310
311 /*
312  * Class:     java_lang_VMClass
313  * Method:    getDeclaredFields
314  * Signature: (Z)[Ljava/lang/reflect/Field;
315  */
316 JNIEXPORT java_objectarray* JNICALL Java_java_lang_VMClass_getDeclaredFields (JNIEnv *env ,  struct java_lang_VMClass* this , s4 public_only)
317 {
318     classinfo *c = (classinfo *) (this->vmData);
319     classinfo *class_field;
320     java_objectarray *array_field; /* result: array of field-objects */
321     int public_fields = 0;         /* number of elements in field-array */
322     int pos = 0;
323     int i;
324
325     /* determine number of fields */
326     for (i = 0; i < c->fieldscount; i++) 
327         if ((c->fields[i].flags & ACC_PUBLIC) || (!public_only)) public_fields++;
328
329     class_field = loader_load(utf_new_char("java/lang/reflect/Field"));
330
331     if (!class_field) 
332         return NULL;
333
334     /* create array of fields */
335     array_field = builtin_anewarray(public_fields, class_field);
336
337     /* creation of array failed */
338     if (!array_field) 
339         return NULL;
340
341     /* get the fields and store in the array */    
342     for (i = 0; i < c->fieldscount; i++) 
343         if ( (c->fields[i].flags & ACC_PUBLIC) || (!public_only))
344             array_field->data[pos++] = (java_objectheader*) Java_java_lang_VMClass_getField0
345                                                              (env,
346                                                               this,
347                                                               (java_lang_String*) javastring_new(c->fields[i].name), 
348                                                               public_only);
349     return array_field;
350 }
351
352 /*
353  * Class:     java/lang/Class
354  * Method:    getInterfaces
355  * Signature: ()[Ljava/lang/Class;
356  */
357 JNIEXPORT java_objectarray* JNICALL Java_java_lang_VMClass_getInterfaces ( JNIEnv *env ,  struct java_lang_VMClass* this)
358 {
359         classinfo *c = (classinfo*) (this->vmData);
360         u4 i;
361         java_objectarray *a = builtin_anewarray (c->interfacescount, class_java_lang_Class);
362         if (!a) return NULL;
363         for (i=0; i<c->interfacescount; i++) {
364                 use_class_as_object (c->interfaces[i]);
365
366                 a->data[i] = (java_objectheader*) c->interfaces[i];
367                 }
368         return a;
369 }
370
371
372 /*
373  * Class:     java/lang/Class
374  * Method:    getMethod0
375  * Signature: (Ljava/lang/String;[Ljava/lang/Class;I)Ljava/lang/reflect/Method;
376  */
377 JNIEXPORT struct java_lang_reflect_Method* JNICALL Java_java_lang_VMClass_getMethod0 ( JNIEnv *env ,  struct java_lang_Class* 
378         this, struct java_lang_String* name, java_objectarray* types, s4 which)
379 {
380     classinfo *c; 
381     classinfo *clazz = (classinfo *) this;
382     java_lang_reflect_Method* o;         /* result: Method-object */ 
383     java_objectarray *exceptiontypes;    /* the exceptions thrown by the method */
384     methodinfo *m;                       /* the method to be represented */
385
386     c = (classinfo*) loader_load(utf_new_char ("java/lang/reflect/Method"));
387     o = (java_lang_reflect_Method*) native_new_and_init(c);
388
389     /* find the method */
390     m = class_resolvemethod_approx (
391                 clazz, 
392                 javastring_toutf(name, false),
393                 create_methodsig(types,0)
394         );
395
396     if (!m || (which==MEMBER_PUBLIC && !(m->flags & ACC_PUBLIC)))
397     {
398         /* no apropriate method was found */
399         exceptionptr = native_new_and_init (class_java_lang_NoSuchMethodException);
400         return NULL;
401     }
402    
403     /* array of exceptions declared to be thrown, information not available !! */
404     exceptiontypes = builtin_anewarray (0, class_java_lang_Class);
405
406     /* initialize instance fields */
407     setfield_critical(c,o,"clazz",          "Ljava/lang/Class;",  jobject, (jobject) clazz /*this*/);
408     setfield_critical(c,o,"parameterTypes", "[Ljava/lang/Class;", jobject, (jobject) types);
409     setfield_critical(c,o,"exceptionTypes", "[Ljava/lang/Class;", jobject, (jobject) exceptiontypes);
410     setfield_critical(c,o,"name",           "Ljava/lang/String;", jstring, javastring_new(m->name));
411     setfield_critical(c,o,"modifiers",      "I",                  jint,    m->flags);
412     setfield_critical(c,o,"slot",           "I",                  jint,    0); 
413     setfield_critical(c,o,"returnType",     "Ljava/lang/Class;",  jclass,  get_returntype(m));
414
415     return o;
416 }
417
418 /*
419  * Class:     java_lang_VMClass
420  * Method:    getDeclaredMethods
421  * Signature: (Z)[Ljava/lang/reflect/Method;
422  */
423 JNIEXPORT java_objectarray* JNICALL Java_java_lang_VMClass_getDeclaredMethods (JNIEnv *env ,  struct java_lang_VMClass* this , s4 public_only)
424 {
425     classinfo *c = (classinfo *) this->vmData;    
426     java_objectheader *o;
427     classinfo *class_method;
428     java_objectarray *array_method;     /* result: array of Method-objects */
429     java_objectarray *exceptiontypes;   /* the exceptions thrown by the method */
430     methodinfo *m;                      /* the current method to be represented */    
431     int public_methods = 0;             /* number of public methods of the class */
432     int pos = 0;
433     int i;
434     utf *utf_constr=utf_new_char("<init>");
435     utf *utf_clinit=utf_new_char("<clinit>");
436
437
438     class_method = (classinfo*) loader_load(utf_new_char ("java/lang/reflect/Method"));
439     if (!class_method) 
440         return NULL;
441
442 /* JOWENN: array classes do not declare methods according to mauve test. It should be considered, if 
443    we should return to my old clone method overriding instead of declaring it as a member function */
444    if (Java_java_lang_VMClass_isArray(env,this)) {
445         return builtin_anewarray(0, class_method);
446    }
447
448
449     /* determine number of methods */
450     for (i = 0; i < c->methodscount; i++) 
451         if ((((c->methods[i].flags & ACC_PUBLIC)) || (!public_only)) && 
452         (!
453                 ((c->methods[i].name==utf_constr) ||
454                 (c->methods[i].name==utf_clinit) )
455         )) public_methods++;
456
457 /*      
458     class_showmethods(class_method);
459     panic("JOWENN");
460 */
461     
462
463     array_method = builtin_anewarray(public_methods, class_method);
464
465     if (!array_method) 
466         return NULL;
467
468     for (i = 0; i < c->methodscount; i++) 
469         if (((c->methods[i].flags & ACC_PUBLIC) || (!public_only)) && 
470        (!
471                 ((c->methods[i].name==utf_constr) ||
472                 (c->methods[i].name==utf_clinit) )
473         )) {
474
475             m = &c->methods[i];     
476             o = native_new_and_init(class_method);     
477             array_method->data[pos++] = o;
478
479             /* array of exceptions declared to be thrown, information not available !! */
480             exceptiontypes = builtin_anewarray (0, class_java_lang_Class);
481
482
483             /* initialize instance fields */
484 /*          ((java_lang_reflect_Method*)o)->flag=(m->flags & 
485                 (ACC_PUBLIC | ACC_PRIVATE | ACC_PROTECTED | ACC_ABSTRACT | ACC_STATIC | ACC_FINAL |
486                         ACC_SYNCHRONIZED | ACC_NATIVE | ACC_STRICT)
487             );*/
488             setfield_critical(class_method,o,"declaringClass",          "Ljava/lang/Class;",  jobject, (jobject) c /*this*/);
489             setfield_critical(class_method,o,"name",           "Ljava/lang/String;", jstring, javastring_new(m->name));
490 /*          setfield_critical(class_method,o,"flag",      "I",               jint,   (m->flags &
491                                         (ACC_PUBLIC | ACC_PRIVATE | ACC_PROTECTED | ACC_ABSTRACT | ACC_STATIC | ACC_FINAL |
492                                         ACC_SYNCHRONIZED | ACC_NATIVE | ACC_STRICT)));*/
493             setfield_critical(class_method,o,"slot",           "I",                  jint,    i); 
494 /*          setfield_critical(class_method,o,"returnType",     "Ljava/lang/Class;",  jclass,  get_returntype(m));
495             setfield_critical(class_method,o,"exceptionTypes", "[Ljava/lang/Class;", jobject, (jobject) exceptiontypes);
496             setfield_critical(class_method,o,"parameterTypes", "[Ljava/lang/Class;", jobject, (jobject) get_parametertypes(m));*/
497         }            
498
499     return array_method;
500 }
501
502 /*
503  * Class:     java/lang/Class
504  * Method:    getModifiers
505  * Signature: ()I
506  */
507 JNIEXPORT s4 JNICALL Java_java_lang_VMClass_getModifiers ( JNIEnv *env ,  struct java_lang_VMClass* this)
508 {
509   classinfo *c = (classinfo *) (this->vmData);
510   return c->flags;
511 }
512
513 /*
514  * Class:     java/lang/Class
515  * Method:    getName
516  * Signature: ()Ljava/lang/String;
517  */
518 JNIEXPORT struct java_lang_String* JNICALL Java_java_lang_VMClass_getName ( JNIEnv *env ,  struct java_lang_VMClass* this)
519 {
520     u4 dimCnt;
521     classinfo *c = (classinfo*) (this->vmData);
522
523     char *utf__ptr  =  c->name->text;      /* current position in utf-text */
524     char **utf_ptr  =  &utf__ptr;
525     char *desc_end =  utf_end(c->name);   /* points behind utf string     */
526     java_lang_String *s;
527     char *str;
528     s4   len;
529     s4   i;
530     if (runverbose) log_text("Java_java_lang_VMClass_getName");
531
532     dimCnt=0;
533     while ( *utf_ptr != desc_end ) {
534         if (utf_nextu2(utf_ptr)=='[') dimCnt++;
535         else break;
536     }
537     utf__ptr=(*utf_ptr)-1;
538
539     len=0;
540     if (((*utf_ptr)+1)==desc_end) {
541             for (i=0;i<PRIMITIVETYPE_COUNT;i++) {
542                 if (primitivetype_table[i].typesig==(*utf__ptr)) {
543                         len=dimCnt*2+strlen(primitivetype_table[i].name);
544                         str=MNEW(char,len+1);
545                         strcpy(str,primitivetype_table[i].name);
546                         break;
547                 }
548             }
549     }
550     if (len==0) {
551         len=dimCnt+strlen(c->name->text);
552         str=MNEW(char,len+1);
553         strcpy(str,utf__ptr);      
554     }   
555
556     dimCnt=len-2*dimCnt;
557     str[len]=0;
558     for (i=len-1;i>=dimCnt;i=i-2) {
559         str[i]=']';
560         str[i-1]='[';
561     }
562     s=(java_lang_String*)javastring_new(utf_new_char(str));
563     MFREE(str,char,len+1);
564
565     if (!s) return NULL;
566
567         /* return string where '/' is replaced by '.' */
568         for (i=0; i<s->value->header.size; i++) {
569                 if (s->value->data[i] == '/') s->value->data[i] = '.';
570                 }
571         
572         return s;
573 }
574
575
576
577 /*
578  * Class:     java/lang/Class
579  * Method:    getProtectionDomain0
580  * Signature: ()Ljava/security/ProtectionDomain;
581  */
582 JNIEXPORT struct java_security_ProtectionDomain* JNICALL Java_java_lang_VMClass_getProtectionDomain0 ( JNIEnv *env ,  struct java_lang_Class* this)
583 {
584   log_text("Java_java_lang_VMClass_getProtectionDomain0  called");
585   return NULL;
586 }
587
588 /*
589  * Class:     java/lang/Class
590  * Method:    getSigners
591  * Signature: ()[Ljava/lang/Object;
592  */
593 JNIEXPORT java_objectarray* JNICALL Java_java_lang_VMClass_getSigners ( JNIEnv *env ,  struct java_lang_Class* this)
594 {
595   log_text("Java_java_lang_VMClass_getSigners  called");
596   return NULL;
597 }
598
599 /*
600  * Class:     java/lang/Class
601  * Method:    getSuperclass
602  * Signature: ()Ljava/lang/Class;
603  */
604 JNIEXPORT struct java_lang_Class* JNICALL Java_java_lang_VMClass_getSuperclass ( JNIEnv *env ,  struct java_lang_VMClass* this)
605 {
606         classinfo *cl= ((classinfo*)this->vmData);
607         classinfo *c=cl -> super;
608
609         if (!c) return NULL;
610
611         use_class_as_object (c);
612         return (java_lang_Class*) c;
613 }
614
615 /*
616  * Class:     java/lang/Class
617  * Method:    isArray
618  * Signature: ()Z
619  */
620 JNIEXPORT s4 JNICALL Java_java_lang_VMClass_isArray ( JNIEnv *env ,  struct java_lang_VMClass* this)
621 {
622     classinfo *c = (classinfo*) (this->vmData);
623     return c->vftbl->arraydesc != NULL;
624 }
625
626 /*
627  * Class:     java/lang/Class
628  * Method:    isAssignableFrom
629  * Signature: (Ljava/lang/Class;)Z
630  */
631 JNIEXPORT s4 JNICALL Java_java_lang_VMClass_isAssignableFrom ( JNIEnv *env ,  struct java_lang_VMClass* this, struct java_lang_Class* sup)
632 {
633 #warning fixme
634         log_text("Java_java_lang_VMClass_isAssignableFrom");
635         if (!this) return 0;
636         if (!sup) return 0;
637         if (!this->vmData) {
638                 panic("sup->vmClass is NULL in VMClass.isAssignableFrom");
639                 return 0;
640         }
641         return (*env)->IsAssignableForm(env, (jclass) sup, (jclass) (this->vmData));
642 }
643
644 /*
645  * Class:     java/lang/Class
646  * Method:    isInstance
647  * Signature: (Ljava/lang/Object;)Z
648  */
649 JNIEXPORT s4 JNICALL Java_java_lang_VMClass_isInstance ( JNIEnv *env ,  struct java_lang_VMClass* this, struct java_lang_Object* obj)
650 {
651         classinfo *clazz = (classinfo*) (this->vmData);
652         return (*env)->IsInstanceOf(env,(jobject) obj,clazz);
653 }
654
655 /*
656  * Class:     java/lang/Class
657  * Method:    isInterface
658  * Signature: ()Z
659  */
660 JNIEXPORT s4 JNICALL Java_java_lang_VMClass_isInterface ( JNIEnv *env ,  struct java_lang_VMClass* this)
661 {
662         classinfo *c = (classinfo*) this->vmData;
663         if (c->flags & ACC_INTERFACE) return true;
664         return false;
665 }
666
667 /*
668  * Class:     java/lang/Class
669  * Method:    isPrimitive
670  * Signature: ()Z
671  */
672 JNIEXPORT s4 JNICALL Java_java_lang_VMClass_isPrimitive ( JNIEnv *env ,  struct java_lang_VMClass* this)
673 {
674   int i;
675   classinfo *c = (classinfo *) this->vmData;
676
677   /* search table of primitive classes */
678   for (i=0;i<PRIMITIVETYPE_COUNT;i++)
679     if (primitivetype_table[i].class_primitive == c) return true;
680
681   return false;
682 }
683
684
685 /*
686  * Class:     java/lang/Class
687  * Method:    registerNatives
688  * Signature: ()V
689  */
690 JNIEXPORT void JNICALL Java_java_lang_VMClass_registerNatives ( JNIEnv *env  )
691 {
692     /* empty */
693 }
694
695 /*
696  * Class:     java/lang/Class
697  * Method:    setProtectionDomain0
698  * Signature: (Ljava/security/ProtectionDomain;)V
699  */
700 JNIEXPORT void JNICALL Java_java_lang_VMClass_setProtectionDomain0 ( JNIEnv *env ,  struct java_lang_Class* this, struct java_security_ProtectionDomain* par1)
701 {
702   if (verbose)
703     log_text("Java_java_lang_VMClass_setProtectionDomain0 called");
704 }
705
706 /*
707  * Class:     java/lang/Class
708  * Method:    setSigners
709  * Signature: ([Ljava/lang/Object;)V
710  */
711 JNIEXPORT void JNICALL Java_java_lang_VMClass_setSigners ( JNIEnv *env ,  struct java_lang_Class* this, java_objectarray* par1)
712 {
713   if (verbose)
714     log_text("Java_java_lang_VMClass_setSigners called");
715 }
716
717
718
719
720
721
722 /*
723  * Class:     java_lang_VMClass
724  * Method:    initialize
725  * Signature: ()V
726  */
727 JNIEXPORT void JNICALL Java_java_lang_VMClass_initialize (JNIEnv *env ,  struct java_lang_VMClass* this ){
728         log_text("Java_java_lang_VMClass_initialize");
729 }
730 /*
731  * Class:     java_lang_VMClass
732  * Method:    loadArrayClass
733  * Signature: (Ljava/lang/String;Ljava/lang/ClassLoader;)Ljava/lang/Class;
734  */
735 JNIEXPORT struct java_lang_Class* JNICALL Java_java_lang_VMClass_loadArrayClass (JNIEnv *env , jclass clazz, struct java_lang_String* par1, struct 
736         java_lang_ClassLoader* par2) {
737                 log_text("Java_java_lang_VMClass_loadArrayClass");
738                 return 0;
739 }
740 /*
741  * Class:     java_lang_VMClass
742  * Method:    throwException
743  * Signature: (Ljava/lang/Throwable;)V
744  */
745 JNIEXPORT void JNICALL Java_java_lang_VMClass_throwException (JNIEnv *env , jclass clazz, struct java_lang_Throwable* par1) {
746         log_text("Java_java_lang_VMClass_throwException");
747 }
748
749 /*
750  * Class:     java_lang_VMClass
751  * Method:    step7
752  * Signature: ()V
753  */
754 JNIEXPORT void JNICALL Java_java_lang_VMClass_step7 (JNIEnv *env ,  struct java_lang_VMClass* this ) {
755         log_text("Java_java_lang_VMClass_step7");
756 }
757 /*
758  * Class:     java_lang_VMClass
759  * Method:    step8
760  * Signature: ()V
761  */
762 JNIEXPORT void JNICALL Java_java_lang_VMClass_step8 (JNIEnv *env ,  struct java_lang_VMClass* this ) {
763         log_text("Java_java_lang_VMClass_step8");
764 }
765
766
767
768 /*
769  * Class:     java_lang_VMClass
770  * Method:    isInitialized
771  * Signature: ()Z
772  */
773 JNIEXPORT s4 JNICALL Java_java_lang_VMClass_isInitialized (JNIEnv *env ,  struct java_lang_VMClass* this ) {
774         log_text("Java_java_lang_VMClass_isInitialized");
775         return 1;
776 }
777 /*
778  * Class:     java_lang_VMClass
779  * Method:    setInitialized
780  * Signature: ()V
781  */
782 JNIEXPORT void JNICALL Java_java_lang_VMClass_setInitialized (JNIEnv *env ,  struct java_lang_VMClass* this ) {
783         log_text("Java_java_lang_VMClass_setInitialized");
784 }