src/native/vm/VMClass.c

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