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        u4 i;
 520        classinfo *c = (classinfo*) (this->vmData);
 521        java_lang_String *s = (java_lang_String*) javastring_new(c->name);
 522        if (!s) return NULL;
 523
 524         /* return string where '/' is replaced by '.' */
 525         for (i=0; i<s->value->header.size; i++) {
 526                 if (s->value->data[i] == '/') s->value->data[i] = '.';
 527                 }
 528
 529         return s;
 530
 531 }
 532
 533 /*
 534  * Class:     java/lang/VMClass
 535  * Method:    getBeautifiedName
 536  * Signature: (Ljava/lang/Class;)Ljava/lang/String;
 537  */
 538 JNIEXPORT struct java_lang_String* JNICALL Java_java_lang_VMClass_getBeautifiedName(JNIEnv *env, jclass clazz, struct java_lang_Class* par1)
 539 {
 540     u4 dimCnt;
 541     classinfo *c = (classinfo*) (par1);
 542
 543     char *utf__ptr  =  c->name->text;      /* current position in utf-text */
 544     char **utf_ptr  =  &utf__ptr;
 545     char *desc_end =  utf_end(c->name);   /* points behind utf string     */
 546     java_lang_String *s;
 547     char *str;
 548     s4   len;
 549     s4   i;
 550     if (runverbose) log_text("Java_java_lang_VMClass_getName");
 551
 552     dimCnt=0;
 553     while ( *utf_ptr != desc_end ) {
 554         if (utf_nextu2(utf_ptr)=='[') dimCnt++;
 555         else break;
 556     }
 557     utf__ptr=(*utf_ptr)-1;
 558
 559     len=0;
 560     if (((*utf_ptr)+1)==desc_end) {
 561             for (i=0;i<PRIMITIVETYPE_COUNT;i++) {
 562                 if (primitivetype_table[i].typesig==(*utf__ptr)) {
 563                         len=dimCnt*2+strlen(primitivetype_table[i].name);
 564                         str=MNEW(char,len+1);
 565                         strcpy(str,primitivetype_table[i].name);
 566                         break;
 567                 }
 568             }
 569     }
 570     if (len==0) {
 571         len=dimCnt+strlen(c->name->text)-2;
 572         str=MNEW(char,len+1);
 573         strncpy(str,++utf__ptr,len-2*dimCnt);
 574     }
 575
 576     dimCnt=len-2*dimCnt;
 577     str[len]=0;
 578     for (i=len-1;i>=dimCnt;i=i-2) {
 579         str[i]=']';
 580         str[i-1]='[';
 581     }
 582     s=(java_lang_String*)javastring_new(utf_new_char(str));
 583     MFREE(str,char,len+1);
 584
 585     if (!s) return NULL;
 586
 587         /* return string where '/' is replaced by '.' */
 588         for (i=0; i<s->value->header.size; i++) {
 589                 if (s->value->data[i] == '/') s->value->data[i] = '.';
 590                 }
 591
 592         return s;
 593 }
 594
 595
 596
 597 /*
 598  * Class:     java/lang/Class
 599  * Method:    getProtectionDomain0
 600  * Signature: ()Ljava/security/ProtectionDomain;
 601  */
 602 JNIEXPORT struct java_security_ProtectionDomain* JNICALL Java_java_lang_VMClass_getProtectionDomain0 ( JNIEnv *env ,  struct java_lang_Class* this)
 603 {
 604   log_text("Java_java_lang_VMClass_getProtectionDomain0  called");
 605   return NULL;
 606 }
 607
 608 /*
 609  * Class:     java/lang/Class
 610  * Method:    getSigners
 611  * Signature: ()[Ljava/lang/Object;
 612  */
 613 JNIEXPORT java_objectarray* JNICALL Java_java_lang_VMClass_getSigners ( JNIEnv *env ,  struct java_lang_Class* this)
 614 {
 615   log_text("Java_java_lang_VMClass_getSigners  called");
 616   return NULL;
 617 }
 618
 619 /*
 620  * Class:     java/lang/Class
 621  * Method:    getSuperclass
 622  * Signature: ()Ljava/lang/Class;
 623  */
 624 JNIEXPORT struct java_lang_Class* JNICALL Java_java_lang_VMClass_getSuperclass ( JNIEnv *env ,  struct java_lang_VMClass* this)
 625 {
 626         classinfo *cl= ((classinfo*)this->vmData);
 627         classinfo *c=cl -> super;
 628
 629         if (!c) return NULL;
 630
 631         use_class_as_object (c);
 632         return (java_lang_Class*) c;
 633 }
 634
 635 /*
 636  * Class:     java/lang/Class
 637  * Method:    isArray
 638  * Signature: ()Z
 639  */
 640 JNIEXPORT s4 JNICALL Java_java_lang_VMClass_isArray ( JNIEnv *env ,  struct java_lang_VMClass* this)
 641 {
 642     classinfo *c = (classinfo*) (this->vmData);
 643     return c->vftbl->arraydesc != NULL;
 644 }
 645
 646 /*
 647  * Class:     java/lang/Class
 648  * Method:    isAssignableFrom
 649  * Signature: (Ljava/lang/Class;)Z
 650  */
 651 JNIEXPORT s4 JNICALL Java_java_lang_VMClass_isAssignableFrom ( JNIEnv *env ,  struct java_lang_VMClass* this, struct java_lang_Class* sup)
 652 {
 653 #warning fixme
 654         log_text("Java_java_lang_VMClass_isAssignableFrom");
 655         if (!this) return 0;
 656         if (!sup) return 0;
 657         if (!this->vmData) {
 658                 panic("sup->vmClass is NULL in VMClass.isAssignableFrom");
 659                 return 0;
 660         }
 661         return (*env)->IsAssignableForm(env, (jclass) sup, (jclass) (this->vmData));
 662 }
 663
 664 /*
 665  * Class:     java/lang/Class
 666  * Method:    isInstance
 667  * Signature: (Ljava/lang/Object;)Z
 668  */
 669 JNIEXPORT s4 JNICALL Java_java_lang_VMClass_isInstance ( JNIEnv *env ,  struct java_lang_VMClass* this, struct java_lang_Object* obj)
 670 {
 671         classinfo *clazz = (classinfo*) (this->vmData);
 672         return (*env)->IsInstanceOf(env,(jobject) obj,clazz);
 673 }
 674
 675 /*
 676  * Class:     java/lang/Class
 677  * Method:    isInterface
 678  * Signature: ()Z
 679  */
 680 JNIEXPORT s4 JNICALL Java_java_lang_VMClass_isInterface ( JNIEnv *env ,  struct java_lang_VMClass* this)
 681 {
 682         classinfo *c = (classinfo*) this->vmData;
 683         if (c->flags & ACC_INTERFACE) return true;
 684         return false;
 685 }
 686
 687 /*
 688  * Class:     java/lang/Class
 689  * Method:    isPrimitive
 690  * Signature: ()Z
 691  */
 692 JNIEXPORT s4 JNICALL Java_java_lang_VMClass_isPrimitive ( JNIEnv *env ,  struct java_lang_VMClass* this)
 693 {
 694   int i;
 695   classinfo *c = (classinfo *) this->vmData;
 696
 697   /* search table of primitive classes */
 698   for (i=0;i<PRIMITIVETYPE_COUNT;i++)
 699     if (primitivetype_table[i].class_primitive == c) return true;
 700
 701   return false;
 702 }
 703
 704
 705 /*
 706  * Class:     java/lang/Class
 707  * Method:    registerNatives
 708  * Signature: ()V
 709  */
 710 JNIEXPORT void JNICALL Java_java_lang_VMClass_registerNatives ( JNIEnv *env  )
 711 {
 712     /* empty */
 713 }
 714
 715 /*
 716  * Class:     java/lang/Class
 717  * Method:    setProtectionDomain0
 718  * Signature: (Ljava/security/ProtectionDomain;)V
 719  */
 720 JNIEXPORT void JNICALL Java_java_lang_VMClass_setProtectionDomain0 ( JNIEnv *env ,  struct java_lang_Class* this, struct java_security_ProtectionDomain* par1)
 721 {
 722   if (verbose)
 723     log_text("Java_java_lang_VMClass_setProtectionDomain0 called");
 724 }
 725
 726 /*
 727  * Class:     java/lang/Class
 728  * Method:    setSigners
 729  * Signature: ([Ljava/lang/Object;)V
 730  */
 731 JNIEXPORT void JNICALL Java_java_lang_VMClass_setSigners ( JNIEnv *env ,  struct java_lang_Class* this, java_objectarray* par1)
 732 {
 733   if (verbose)
 734     log_text("Java_java_lang_VMClass_setSigners called");
 735 }
 736
 737
 738
 739
 740
 741
 742 /*
 743  * Class:     java_lang_VMClass
 744  * Method:    initialize
 745  * Signature: ()V
 746  */
 747 JNIEXPORT void JNICALL Java_java_lang_VMClass_initialize (JNIEnv *env ,  struct java_lang_VMClass* this ){
 748         log_text("Java_java_lang_VMClass_initialize");
 749 }
 750 /*
 751  * Class:     java_lang_VMClass
 752  * Method:    loadArrayClass
 753  * Signature: (Ljava/lang/String;Ljava/lang/ClassLoader;)Ljava/lang/Class;
 754  */
 755 JNIEXPORT struct java_lang_Class* JNICALL Java_java_lang_VMClass_loadArrayClass (JNIEnv *env , jclass clazz, struct java_lang_String* par1, struct
 756         java_lang_ClassLoader* par2) {
 757                 log_text("Java_java_lang_VMClass_loadArrayClass");
 758                 return 0;
 759 }
 760 /*
 761  * Class:     java_lang_VMClass
 762  * Method:    throwException
 763  * Signature: (Ljava/lang/Throwable;)V
 764  */
 765 JNIEXPORT void JNICALL Java_java_lang_VMClass_throwException (JNIEnv *env , jclass clazz, struct java_lang_Throwable* par1) {
 766         log_text("Java_java_lang_VMClass_throwException");
 767 }
 768
 769 /*
 770  * Class:     java_lang_VMClass
 771  * Method:    step7
 772  * Signature: ()V
 773  */
 774 JNIEXPORT void JNICALL Java_java_lang_VMClass_step7 (JNIEnv *env ,  struct java_lang_VMClass* this ) {
 775         log_text("Java_java_lang_VMClass_step7");
 776 }
 777 /*
 778  * Class:     java_lang_VMClass
 779  * Method:    step8
 780  * Signature: ()V
 781  */
 782 JNIEXPORT void JNICALL Java_java_lang_VMClass_step8 (JNIEnv *env ,  struct java_lang_VMClass* this ) {
 783         log_text("Java_java_lang_VMClass_step8");
 784 }
 785
 786
 787
 788 /*
 789  * Class:     java_lang_VMClass
 790  * Method:    isInitialized
 791  * Signature: ()Z
 792  */
 793 JNIEXPORT s4 JNICALL Java_java_lang_VMClass_isInitialized (JNIEnv *env ,  struct java_lang_VMClass* this ) {
 794         log_text("Java_java_lang_VMClass_isInitialized");
 795         return 1;
 796 }
 797 /*
 798  * Class:     java_lang_VMClass
 799  * Method:    setInitialized
 800  * Signature: ()V
 801  */
 802 JNIEXPORT void JNICALL Java_java_lang_VMClass_setInitialized (JNIEnv *env ,  struct java_lang_VMClass* this ) {
 803         log_text("Java_java_lang_VMClass_setInitialized");
 804 }