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         if ( !(c = class_get(u)) ) {
  45             log_text("forName: would need classloader");
  46             /*utf_display(u);*/
  47
  48             c = loader_load(u);
  49             if (c == NULL) {
  50                 /* class was not loaded. raise exception */
  51                 exceptionptr =
  52                     native_new_and_init_string(class_java_lang_ClassNotFoundException, s);
  53                 return NULL;
  54             }
  55         }
  56
  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
 123
 124     /* determine number of constructors */
 125     for (i = 0; i < c->methodscount; i++)
 126         if ((((c->methods[i].flags & ACC_PUBLIC)) || (!public_only)) &&
 127                 (c->methods[i].name==utf_constr)) public_methods++;
 128
 129     class_constructor = (classinfo*) loader_load(utf_new_char ("java/lang/reflect/Constructor"));
 130
 131     if (!class_constructor)
 132         return NULL;
 133
 134     array_constructor = builtin_anewarray(public_methods, class_constructor);
 135
 136     if (!array_constructor)
 137         return NULL;
 138
 139     for (i = 0; i < c->methodscount; i++)
 140         if ((c->methods[i].flags & ACC_PUBLIC) || (!public_only)){
 141
 142             m = &c->methods[i];
 143             if (m->name!=utf_constr) continue;
 144             o = native_new_and_init(class_constructor);
 145             array_constructor->data[pos++] = o;
 146
 147             /* array of exceptions declared to be thrown, information not available !! */
 148             exceptiontypes = builtin_anewarray (0, class_java_lang_Class);
 149
 150 /*          class_showconstantpool(class_constructor);*/
 151             /* initialize instance fields */
 152 /*          ((java_lang_reflect_Constructor*)o)->flag=(m->flags & (ACC_PRIVATE | ACC_PUBLIC | ACC_PROTECTED));*/
 153             setfield_critical(class_constructor,o,"clazz",          "Ljava/lang/Class;",  jobject, (jobject) c /*this*/);
 154             setfield_critical(class_constructor,o,"slot",           "I",                     jint,    i);
 155 /*          setfield_critical(class_constructor,o,"flag",           "I",                     jint,    (m->flags & (ACC_PRIVATE |
 156                         ACC_PUBLIC | ACC_PROTECTED))); */
 157             setfield_critical(class_constructor,o,"exceptionTypes", "[Ljava/lang/Class;", jobject, (jobject) exceptiontypes);
 158             setfield_critical(class_constructor,o,"parameterTypes", "[Ljava/lang/Class;", jobject, (jobject) get_parametertypes(m));
 159         }
 160
 161 log_text("leaving Java_java_lang_VMClass_getDeclaredConstructors");
 162 return array_constructor;
 163
 164
 165
 166
 167 /*  panic("Java_java_lang_Class_getConstructors0 called");
 168   return NULL;*/
 169 }
 170
 171
 172 /*
 173  * Class:     java_lang_VMClass
 174  * Method:    getDeclaredClasses
 175  * Signature: (Z)[Ljava/lang/Class;
 176  */
 177 JNIEXPORT java_objectarray* JNICALL Java_java_lang_VMClass_getDeclaredClasses (JNIEnv *env ,  struct java_lang_VMClass* this , s4 publicOnly)
 178 {
 179 #warning fix the public only case
 180   classinfo *c = (classinfo *) (this->vmData);
 181   int pos = 0;                /* current declared class */
 182   int declaredclasscount = 0; /* number of declared classes */
 183   java_objectarray *result;   /* array of declared classes */
 184   int i;
 185
 186   if (!this)
 187     return NULL;
 188
 189   if (!this->vmData)
 190     return NULL;
 191
 192   if (!Java_java_lang_VMClass_isPrimitive(env, this) && (c->name->text[0]!='[')) {
 193     /* determine number of declared classes */
 194     for (i = 0; i < c->innerclasscount; i++) {
 195       if (c->innerclass[i].outer_class == c)
 196         /* outer class is this class */
 197         declaredclasscount++;
 198     }
 199   }
 200
 201   result = builtin_anewarray(declaredclasscount, class_java_lang_Class);
 202
 203   for (i = 0; i < c->innerclasscount; i++) {
 204
 205     classinfo *inner =  c->innerclass[i].inner_class;
 206     classinfo *outer =  c->innerclass[i].outer_class;
 207
 208     if (outer == c) {
 209       /* outer class is this class, store innerclass in array */
 210       use_class_as_object (inner);
 211       result->data[pos++] = (java_objectheader *) inner;
 212     }
 213   }
 214
 215   return result;
 216 }
 217
 218 /*
 219  * Class:     java/lang/Class
 220  * Method:    getDeclaringClass
 221  * Signature: ()Ljava/lang/Class;
 222  */
 223 JNIEXPORT struct java_lang_Class* JNICALL Java_java_lang_VMClass_getDeclaringClass ( JNIEnv *env ,  struct java_lang_VMClass* this)
 224 {
 225 #warning fixme
 226   classinfo *c = (classinfo *) (this->vmData);
 227   log_text("Java_java_lang_VMClass_getDeclaringClass");
 228
 229   if (this && this->vmData && !Java_java_lang_VMClass_isPrimitive(env, this) && (c->name->text[0]!='[')) {
 230     int i;
 231
 232     if (c->innerclasscount == 0)  /* no innerclasses exist */
 233         return NULL;
 234
 235     for (i = 0; i < c->innerclasscount; i++) {
 236
 237       classinfo *inner =  c->innerclass[i].inner_class;
 238       classinfo *outer =  c->innerclass[i].outer_class;
 239
 240       if (inner == c) {
 241         /* innerclass is this class */
 242         use_class_as_object (outer);
 243         return (java_lang_Class*) outer;
 244       }
 245     }
 246   }
 247
 248   /* return NULL for arrayclasses and primitive classes */
 249   return NULL;
 250 }
 251
 252 /*
 253  * Class:     java/lang/Class
 254  * Method:    getField0
 255  * Signature: (Ljava/lang/String;I)Ljava/lang/reflect/Field;
 256  */
 257 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)
 258 {
 259     classinfo *c, *fieldtype;
 260     fieldinfo *f;               /* the field to be represented */
 261     java_lang_reflect_Field *o; /* result: field-object */
 262     utf *desc;                  /* the fielddescriptor */
 263     int idx;
 264
 265     /* create Field object */
 266     c = (classinfo*) loader_load(utf_new_char ("java/lang/reflect/Field"));
 267     o = (java_lang_reflect_Field*) native_new_and_init(c);
 268
 269     /* get fieldinfo entry */
 270     idx = class_findfield_index_approx((classinfo*) (this->vmData), javastring_toutf(name, false));
 271     if (idx<0) {
 272             exceptionptr = native_new_and_init(class_java_lang_NoSuchFieldException);
 273             return NULL;
 274         }
 275     f= &(((struct classinfo*)(this->vmData))->fields[idx]);
 276     if (f) {
 277
 278         if ( public_only && !(f->flags & ACC_PUBLIC))
 279         {
 280             /* field is not public  and public only had been requested*/
 281             exceptionptr = native_new_and_init(class_java_lang_NoSuchFieldException);
 282             return NULL;
 283         }
 284
 285       desc = f->descriptor;
 286       fieldtype = class_from_descriptor(desc->text,utf_end(desc),NULL,true);
 287       if (!fieldtype) return NULL;
 288
 289       /* initialize instance fields */
 290       setfield_critical(c,o,"declaringClass",          "Ljava/lang/Class;",  jobject, (jobject) (this->vmData) /*this*/);
 291 /*      ((java_lang_reflect_Field*)(o))->flag=f->flags;*/
 292       /* save type in slot-field for faster processing */
 293 /*      setfield_critical(c,o,"flag",           "I",                jint,    (jint) f->flags);  */
 294       setfield_critical(c,o,"slot",           "I",                  jint,    (jint) idx);
 295       setfield_critical(c,o,"name",           "Ljava/lang/String;", jstring, (jstring) name);
 296       /*setfield_critical(c,o,"type",           "Ljava/lang/Class;",  jclass,  fieldtype);*/
 297
 298       return o;
 299     }
 300
 301     return NULL;
 302 }
 303
 304
 305 /*
 306  * Class:     java_lang_VMClass
 307  * Method:    getDeclaredFields
 308  * Signature: (Z)[Ljava/lang/reflect/Field;
 309  */
 310 JNIEXPORT java_objectarray* JNICALL Java_java_lang_VMClass_getDeclaredFields (JNIEnv *env ,  struct java_lang_VMClass* this , s4 public_only)
 311 {
 312     classinfo *c = (classinfo *) (this->vmData);
 313     classinfo *class_field;
 314     java_objectarray *array_field; /* result: array of field-objects */
 315     int public_fields = 0;         /* number of elements in field-array */
 316     int pos = 0;
 317     int i;
 318
 319     /* determine number of fields */
 320     for (i = 0; i < c->fieldscount; i++)
 321         if ((c->fields[i].flags & ACC_PUBLIC) || (!public_only)) public_fields++;
 322
 323     class_field = loader_load(utf_new_char("java/lang/reflect/Field"));
 324
 325     if (!class_field)
 326         return NULL;
 327
 328     /* create array of fields */
 329     array_field = builtin_anewarray(public_fields, class_field);
 330
 331     /* creation of array failed */
 332     if (!array_field)
 333         return NULL;
 334
 335     /* get the fields and store in the array */
 336     for (i = 0; i < c->fieldscount; i++)
 337         if ( (c->fields[i].flags & ACC_PUBLIC) || (!public_only))
 338             array_field->data[pos++] = (java_objectheader*) Java_java_lang_VMClass_getField0
 339                                                              (env,
 340                                                               this,
 341                                                               (java_lang_String*) javastring_new(c->fields[i].name),
 342                                                               public_only);
 343     return array_field;
 344 }
 345
 346 /*
 347  * Class:     java/lang/Class
 348  * Method:    getInterfaces
 349  * Signature: ()[Ljava/lang/Class;
 350  */
 351 JNIEXPORT java_objectarray* JNICALL Java_java_lang_VMClass_getInterfaces ( JNIEnv *env ,  struct java_lang_VMClass* this)
 352 {
 353         classinfo *c = (classinfo*) (this->vmData);
 354         u4 i;
 355         java_objectarray *a = builtin_anewarray (c->interfacescount, class_java_lang_Class);
 356         if (!a) return NULL;
 357         for (i=0; i<c->interfacescount; i++) {
 358                 use_class_as_object (c->interfaces[i]);
 359
 360                 a->data[i] = (java_objectheader*) c->interfaces[i];
 361                 }
 362         return a;
 363 }
 364
 365
 366 /*
 367  * Class:     java/lang/Class
 368  * Method:    getMethod0
 369  * Signature: (Ljava/lang/String;[Ljava/lang/Class;I)Ljava/lang/reflect/Method;
 370  */
 371 JNIEXPORT struct java_lang_reflect_Method* JNICALL Java_java_lang_VMClass_getMethod0 ( JNIEnv *env ,  struct java_lang_Class*
 372         this, struct java_lang_String* name, java_objectarray* types, s4 which)
 373 {
 374     classinfo *c;
 375     classinfo *clazz = (classinfo *) this;
 376     java_lang_reflect_Method* o;         /* result: Method-object */
 377     java_objectarray *exceptiontypes;    /* the exceptions thrown by the method */
 378     methodinfo *m;                       /* the method to be represented */
 379
 380     c = (classinfo*) loader_load(utf_new_char ("java/lang/reflect/Method"));
 381     o = (java_lang_reflect_Method*) native_new_and_init(c);
 382
 383     /* find the method */
 384     m = class_resolvemethod_approx (
 385                 clazz,
 386                 javastring_toutf(name, false),
 387                 create_methodsig(types,0)
 388         );
 389
 390     if (!m || (which==MEMBER_PUBLIC && !(m->flags & ACC_PUBLIC)))
 391     {
 392         /* no apropriate method was found */
 393         exceptionptr = native_new_and_init (class_java_lang_NoSuchMethodException);
 394         return NULL;
 395     }
 396
 397     /* array of exceptions declared to be thrown, information not available !! */
 398     exceptiontypes = builtin_anewarray (0, class_java_lang_Class);
 399
 400     /* initialize instance fields */
 401     setfield_critical(c,o,"clazz",          "Ljava/lang/Class;",  jobject, (jobject) clazz /*this*/);
 402     setfield_critical(c,o,"parameterTypes", "[Ljava/lang/Class;", jobject, (jobject) types);
 403     setfield_critical(c,o,"exceptionTypes", "[Ljava/lang/Class;", jobject, (jobject) exceptiontypes);
 404     setfield_critical(c,o,"name",           "Ljava/lang/String;", jstring, javastring_new(m->name));
 405     setfield_critical(c,o,"modifiers",      "I",                  jint,    m->flags);
 406     setfield_critical(c,o,"slot",           "I",                  jint,    0);
 407     setfield_critical(c,o,"returnType",     "Ljava/lang/Class;",  jclass,  get_returntype(m));
 408
 409     return o;
 410 }
 411
 412 /*
 413  * Class:     java_lang_VMClass
 414  * Method:    getDeclaredMethods
 415  * Signature: (Z)[Ljava/lang/reflect/Method;
 416  */
 417 JNIEXPORT java_objectarray* JNICALL Java_java_lang_VMClass_getDeclaredMethods (JNIEnv *env ,  struct java_lang_VMClass* this , s4 public_only)
 418 {
 419     classinfo *c = (classinfo *) this->vmData;
 420     java_objectheader *o;
 421     classinfo *class_method;
 422     java_objectarray *array_method;     /* result: array of Method-objects */
 423     java_objectarray *exceptiontypes;   /* the exceptions thrown by the method */
 424     methodinfo *m;                      /* the current method to be represented */
 425     int public_methods = 0;             /* number of public methods of the class */
 426     int pos = 0;
 427     int i;
 428
 429     /* determine number of methods */
 430     for (i = 0; i < c->methodscount; i++)
 431         if (((c->methods[i].flags & ACC_PUBLIC)) || (!public_only)) public_methods++;
 432
 433     class_method = (classinfo*) loader_load(utf_new_char ("java/lang/reflect/Method"));
 434 /*
 435     class_showmethods(class_method);
 436     panic("JOWENN");
 437 */
 438     if (!class_method)
 439         return NULL;
 440
 441
 442     array_method = builtin_anewarray(public_methods, class_method);
 443
 444     if (!array_method)
 445         return NULL;
 446
 447     for (i = 0; i < c->methodscount; i++)
 448         if ((c->methods[i].flags & ACC_PUBLIC) || (!public_only)){
 449
 450             m = &c->methods[i];
 451             o = native_new_and_init(class_method);
 452             array_method->data[pos++] = o;
 453
 454             /* array of exceptions declared to be thrown, information not available !! */
 455             exceptiontypes = builtin_anewarray (0, class_java_lang_Class);
 456
 457
 458             /* initialize instance fields */
 459 /*          ((java_lang_reflect_Method*)o)->flag=(m->flags &
 460                 (ACC_PUBLIC | ACC_PRIVATE | ACC_PROTECTED | ACC_ABSTRACT | ACC_STATIC | ACC_FINAL |
 461                         ACC_SYNCHRONIZED | ACC_NATIVE | ACC_STRICT)
 462             );*/
 463             setfield_critical(class_method,o,"declaringClass",          "Ljava/lang/Class;",  jobject, (jobject) c /*this*/);
 464             setfield_critical(class_method,o,"name",           "Ljava/lang/String;", jstring, javastring_new(m->name));
 465 /*          setfield_critical(class_method,o,"flag",      "I",               jint,   (m->flags &
 466                                         (ACC_PUBLIC | ACC_PRIVATE | ACC_PROTECTED | ACC_ABSTRACT | ACC_STATIC | ACC_FINAL |
 467                                         ACC_SYNCHRONIZED | ACC_NATIVE | ACC_STRICT)));*/
 468             setfield_critical(class_method,o,"slot",           "I",                  jint,    i);
 469 /*          setfield_critical(class_method,o,"returnType",     "Ljava/lang/Class;",  jclass,  get_returntype(m));
 470             setfield_critical(class_method,o,"exceptionTypes", "[Ljava/lang/Class;", jobject, (jobject) exceptiontypes);
 471             setfield_critical(class_method,o,"parameterTypes", "[Ljava/lang/Class;", jobject, (jobject) get_parametertypes(m));*/
 472         }
 473
 474     return array_method;
 475 }
 476
 477 /*
 478  * Class:     java/lang/Class
 479  * Method:    getModifiers
 480  * Signature: ()I
 481  */
 482 JNIEXPORT s4 JNICALL Java_java_lang_VMClass_getModifiers ( JNIEnv *env ,  struct java_lang_VMClass* this)
 483 {
 484   classinfo *c = (classinfo *) (this->vmData);
 485   return c->flags;
 486 }
 487
 488 /*
 489  * Class:     java/lang/Class
 490  * Method:    getName
 491  * Signature: ()Ljava/lang/String;
 492  */
 493 JNIEXPORT struct java_lang_String* JNICALL Java_java_lang_VMClass_getName ( JNIEnv *env ,  struct java_lang_VMClass* this)
 494 {
 495
 496         u4 i;
 497         classinfo *c = (classinfo*) (this->vmData);
 498         java_lang_String *s = (java_lang_String*) javastring_new(c->name);
 499
 500         if (!s) return NULL;
 501
 502         /* return string where '/' is replaced by '.' */
 503         for (i=0; i<s->value->header.size; i++) {
 504                 if (s->value->data[i] == '/') s->value->data[i] = '.';
 505                 }
 506
 507         return s;
 508 }
 509
 510
 511
 512 /*
 513  * Class:     java/lang/Class
 514  * Method:    getProtectionDomain0
 515  * Signature: ()Ljava/security/ProtectionDomain;
 516  */
 517 JNIEXPORT struct java_security_ProtectionDomain* JNICALL Java_java_lang_VMClass_getProtectionDomain0 ( JNIEnv *env ,  struct java_lang_Class* this)
 518 {
 519   log_text("Java_java_lang_VMClass_getProtectionDomain0  called");
 520   return NULL;
 521 }
 522
 523 /*
 524  * Class:     java/lang/Class
 525  * Method:    getSigners
 526  * Signature: ()[Ljava/lang/Object;
 527  */
 528 JNIEXPORT java_objectarray* JNICALL Java_java_lang_VMClass_getSigners ( JNIEnv *env ,  struct java_lang_Class* this)
 529 {
 530   log_text("Java_java_lang_VMClass_getSigners  called");
 531   return NULL;
 532 }
 533
 534 /*
 535  * Class:     java/lang/Class
 536  * Method:    getSuperclass
 537  * Signature: ()Ljava/lang/Class;
 538  */
 539 JNIEXPORT struct java_lang_Class* JNICALL Java_java_lang_VMClass_getSuperclass ( JNIEnv *env ,  struct java_lang_VMClass* this)
 540 {
 541         classinfo *c = ((classinfo*) this->vmData) -> super;
 542         if (!c) return NULL;
 543
 544         use_class_as_object (c);
 545         return (java_lang_Class*) c;
 546 }
 547
 548 /*
 549  * Class:     java/lang/Class
 550  * Method:    isArray
 551  * Signature: ()Z
 552  */
 553 JNIEXPORT s4 JNICALL Java_java_lang_VMClass_isArray ( JNIEnv *env ,  struct java_lang_VMClass* this)
 554 {
 555     classinfo *c = (classinfo*) (this->vmData);
 556     return c->vftbl->arraydesc != NULL;
 557 }
 558
 559 /*
 560  * Class:     java/lang/Class
 561  * Method:    isAssignableFrom
 562  * Signature: (Ljava/lang/Class;)Z
 563  */
 564 JNIEXPORT s4 JNICALL Java_java_lang_VMClass_isAssignableFrom ( JNIEnv *env ,  struct java_lang_VMClass* this, struct java_lang_Class* sup)
 565 {
 566 #warning fixme
 567         log_text("Java_java_lang_VMClass_isAssignableFrom");
 568         if (!this) return 0;
 569         if (!sup) return 0;
 570         if (!sup->vmClass) {
 571                 panic("sup->vmClass is NULL in VMClass.isAssignableFrom");
 572                 return 0;
 573         }
 574         return (*env)->IsAssignableForm(env, (jclass) (this->vmData), (jclass) sup/*->vmClass*/);
 575 }
 576
 577 /*
 578  * Class:     java/lang/Class
 579  * Method:    isInstance
 580  * Signature: (Ljava/lang/Object;)Z
 581  */
 582 JNIEXPORT s4 JNICALL Java_java_lang_VMClass_isInstance ( JNIEnv *env ,  struct java_lang_VMClass* this, struct java_lang_Object* obj)
 583 {
 584         classinfo *clazz = (classinfo*) this;
 585         return (*env)->IsInstanceOf(env,(jobject) obj,clazz);
 586 }
 587
 588 /*
 589  * Class:     java/lang/Class
 590  * Method:    isInterface
 591  * Signature: ()Z
 592  */
 593 JNIEXPORT s4 JNICALL Java_java_lang_VMClass_isInterface ( JNIEnv *env ,  struct java_lang_VMClass* this)
 594 {
 595         classinfo *c = (classinfo*) this->vmData;
 596         if (c->flags & ACC_INTERFACE) return true;
 597         return false;
 598 }
 599
 600 /*
 601  * Class:     java/lang/Class
 602  * Method:    isPrimitive
 603  * Signature: ()Z
 604  */
 605 JNIEXPORT s4 JNICALL Java_java_lang_VMClass_isPrimitive ( JNIEnv *env ,  struct java_lang_VMClass* this)
 606 {
 607   int i;
 608   classinfo *c = (classinfo *) this->vmData;
 609
 610   /* search table of primitive classes */
 611   for (i=0;i<PRIMITIVETYPE_COUNT;i++)
 612     if (primitivetype_table[i].class_primitive == c) return true;
 613
 614   return false;
 615 }
 616
 617
 618 /*
 619  * Class:     java/lang/Class
 620  * Method:    registerNatives
 621  * Signature: ()V
 622  */
 623 JNIEXPORT void JNICALL Java_java_lang_VMClass_registerNatives ( JNIEnv *env  )
 624 {
 625     /* empty */
 626 }
 627
 628 /*
 629  * Class:     java/lang/Class
 630  * Method:    setProtectionDomain0
 631  * Signature: (Ljava/security/ProtectionDomain;)V
 632  */
 633 JNIEXPORT void JNICALL Java_java_lang_VMClass_setProtectionDomain0 ( JNIEnv *env ,  struct java_lang_Class* this, struct java_security_ProtectionDomain* par1)
 634 {
 635   if (verbose)
 636     log_text("Java_java_lang_VMClass_setProtectionDomain0 called");
 637 }
 638
 639 /*
 640  * Class:     java/lang/Class
 641  * Method:    setSigners
 642  * Signature: ([Ljava/lang/Object;)V
 643  */
 644 JNIEXPORT void JNICALL Java_java_lang_VMClass_setSigners ( JNIEnv *env ,  struct java_lang_Class* this, java_objectarray* par1)
 645 {
 646   if (verbose)
 647     log_text("Java_java_lang_VMClass_setSigners called");
 648 }
 649
 650
 651
 652
 653
 654
 655 /*
 656  * Class:     java_lang_VMClass
 657  * Method:    initialize
 658  * Signature: ()V
 659  */
 660 JNIEXPORT void JNICALL Java_java_lang_VMClass_initialize (JNIEnv *env ,  struct java_lang_VMClass* this ){
 661         log_text("Java_java_lang_VMClass_initialize");
 662 }
 663 /*
 664  * Class:     java_lang_VMClass
 665  * Method:    loadArrayClass
 666  * Signature: (Ljava/lang/String;Ljava/lang/ClassLoader;)Ljava/lang/Class;
 667  */
 668 JNIEXPORT struct java_lang_Class* JNICALL Java_java_lang_VMClass_loadArrayClass (JNIEnv *env , jclass clazz, struct java_lang_String* par1, struct
 669         java_lang_ClassLoader* par2) {
 670                 log_text("Java_java_lang_VMClass_loadArrayClass");
 671                 return 0;
 672 }
 673 /*
 674  * Class:     java_lang_VMClass
 675  * Method:    throwException
 676  * Signature: (Ljava/lang/Throwable;)V
 677  */
 678 JNIEXPORT void JNICALL Java_java_lang_VMClass_throwException (JNIEnv *env , jclass clazz, struct java_lang_Throwable* par1) {
 679         log_text("Java_java_lang_VMClass_throwException");
 680 }
 681
 682 /*
 683  * Class:     java_lang_VMClass
 684  * Method:    step7
 685  * Signature: ()V
 686  */
 687 JNIEXPORT void JNICALL Java_java_lang_VMClass_step7 (JNIEnv *env ,  struct java_lang_VMClass* this ) {
 688         log_text("Java_java_lang_VMClass_step7");
 689 }
 690 /*
 691  * Class:     java_lang_VMClass
 692  * Method:    step8
 693  * Signature: ()V
 694  */
 695 JNIEXPORT void JNICALL Java_java_lang_VMClass_step8 (JNIEnv *env ,  struct java_lang_VMClass* this ) {
 696         log_text("Java_java_lang_VMClass_step8");
 697 }
 698
 699
 700
 701 /*
 702  * Class:     java_lang_VMClass
 703  * Method:    isInitialized
 704  * Signature: ()Z
 705  */
 706 JNIEXPORT s4 JNICALL Java_java_lang_VMClass_isInitialized (JNIEnv *env ,  struct java_lang_VMClass* this ) {
 707         log_text("Java_java_lang_VMClass_isInitialized");
 708         return 1;
 709 }
 710 /*
 711  * Class:     java_lang_VMClass
 712  * Method:    setInitialized
 713  * Signature: ()V
 714  */
 715 JNIEXPORT void JNICALL Java_java_lang_VMClass_setInitialized (JNIEnv *env ,  struct java_lang_VMClass* this ) {
 716         log_text("Java_java_lang_VMClass_setInitialized");
 717 }