src/native/vm/java_lang_Class.c

   1 /* src/native/vm/java_lang_Class.c - java/lang/Class
   2
   3    Copyright (C) 1996-2005, 2006, 2007 R. Grafl, A. Krall, C. Kruegel,
   4    C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
   5    E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
   6    J. Wenninger, Institut f. Computersprachen - TU Wien
   7
   8    This file is part of CACAO.
   9
  10    This program is free software; you can redistribute it and/or
  11    modify it under the terms of the GNU General Public License as
  12    published by the Free Software Foundation; either version 2, or (at
  13    your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful, but
  16    WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18    General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  23    02110-1301, USA.
  24
  25    $Id: java_lang_Class.c 8335 2007-08-17 11:04:35Z michi $
  26
  27 */
  28
  29
  30 #include "config.h"
  31
  32 #include <assert.h>
  33 #include <stdint.h>
  34 #include <string.h>
  35
  36 #include "vm/types.h"
  37
  38 #include "mm/memory.h"
  39
  40 #include "native/jni.h"
  41 #include "native/llni.h"
  42 #include "native/native.h"
  43
  44 /* keep this order of the native includes */
  45
  46 #include "native/include/java_lang_String.h"
  47
  48 #if defined(ENABLE_JAVASE)
  49 # if defined(WITH_CLASSPATH_SUN)
  50 #  include "native/include/java_nio_ByteBuffer.h"       /* required by j.l.CL */
  51 # endif
  52 # include "native/include/java_lang_ClassLoader.h"
  53 #endif
  54
  55 #include "native/include/java_lang_Object.h"
  56 #include "native/include/java_lang_Class.h"
  57
  58 #if defined(ENABLE_JAVASE)
  59 # include "native/include/java_lang_reflect_Constructor.h"
  60 # include "native/include/java_lang_reflect_Field.h"
  61 # include "native/include/java_lang_reflect_Method.h"
  62 #endif
  63
  64 #include "native/vm/java_lang_Class.h"
  65 #include "native/vm/java_lang_String.h"
  66
  67 #if defined(ENABLE_JAVASE)
  68 # include "native/vm/reflect.h"
  69 #endif
  70
  71 #include "toolbox/logging.h"
  72
  73 #include "vm/builtin.h"
  74 #include "vm/exceptions.h"
  75 #include "vm/global.h"
  76 #include "vm/initialize.h"
  77 #include "vm/primitive.h"
  78 #include "vm/resolve.h"
  79 #include "vm/stringlocal.h"
  80
  81 #include "vmcore/class.h"
  82 #include "vmcore/loader.h"
  83
  84 #if defined(WITH_CLASSPATH_GNU) && defined(ENABLE_ANNOTATIONS)
  85 #include "vm/vm.h"
  86 #include "vmcore/annotation.h"
  87 #include "native/include/sun_reflect_ConstantPool.h"
  88 #endif
  89
  90 /*
  91  * Class:     java/lang/Class
  92  * Method:    getName
  93  * Signature: ()Ljava/lang/String;
  94  */
  95 java_lang_String *_Jv_java_lang_Class_getName(java_lang_Class *klass)
  96 {
  97         classinfo               *c;
  98         java_lang_String        *s;
  99         java_handle_chararray_t *ca;
 100         u4                       i;
 101
 102         c = (classinfo *) klass;
 103
 104         /* create a java string */
 105
 106         s = (java_lang_String *) javastring_new(c->name);
 107
 108         if (s == NULL)
 109                 return NULL;
 110
 111         /* return string where '/' is replaced by '.' */
 112
 113         LLNI_field_get_ref(s, value, ca);
 114
 115         for (i = 0; i < LLNI_array_size(ca); i++) {
 116                 if (LLNI_array_direct(ca, i) == '/')
 117                         LLNI_array_direct(ca, i) = '.';
 118         }
 119
 120         return s;
 121 }
 122
 123
 124 /*
 125  * Class:     java/lang/Class
 126  * Method:    forName
 127  * Signature: (Ljava/lang/String;ZLjava/lang/ClassLoader;)Ljava/lang/Class;
 128  */
 129 #if defined(ENABLE_JAVASE)
 130 java_lang_Class *_Jv_java_lang_Class_forName(java_lang_String *name, s4 initialize, java_lang_ClassLoader *loader)
 131 #elif defined(ENABLE_JAVAME_CLDC1_1)
 132 java_lang_Class *_Jv_java_lang_Class_forName(java_lang_String *name)
 133 #endif
 134 {
 135 #if defined(ENABLE_JAVASE)
 136         classloader *cl;
 137 #endif
 138         utf         *ufile;
 139         utf         *uname;
 140         classinfo   *c;
 141         u2          *pos;
 142         s4           i;
 143
 144 #if defined(ENABLE_JAVASE)
 145         cl = loader_hashtable_classloader_add((java_handle_t *) loader);
 146 #endif
 147
 148         /* illegal argument */
 149
 150         if (name == NULL) {
 151                 exceptions_throw_nullpointerexception();
 152                 return NULL;
 153         }
 154
 155         /* create utf string in which '.' is replaced by '/' */
 156
 157         ufile = javastring_toutf((java_handle_t *) name, true);
 158         uname = javastring_toutf((java_handle_t *) name, false);
 159
 160         /* name must not contain '/' (mauve test) */
 161
 162         for (i = 0, pos = LLNI_field_direct(name, value)->data + LLNI_field_direct(name, offset); i < LLNI_field_direct(name, count); i++, pos++) {
 163                 if (*pos == '/') {
 164                         exceptions_throw_classnotfoundexception(uname);
 165                         return NULL;
 166                 }
 167         }
 168
 169         /* try to load, ... */
 170
 171 #if defined(ENABLE_JAVASE)
 172         c = load_class_from_classloader(ufile, cl);
 173 #elif defined(ENABLE_JAVAME_CLDC1_1)
 174         c = load_class_bootstrap(ufile);
 175 #endif
 176
 177         if (c == NULL)
 178             return NULL;
 179
 180         /* link, ... */
 181
 182         if (!link_class(c))
 183                 return NULL;
 184
 185         /* ...and initialize it, if required */
 186
 187 #if defined(ENABLE_JAVASE)
 188         if (initialize)
 189 #endif
 190                 if (!initialize_class(c))
 191                         return NULL;
 192
 193         return (java_lang_Class *) c;
 194 }
 195
 196
 197 /*
 198  * Class:     java/lang/Class
 199  * Method:    isInstance
 200  * Signature: (Ljava/lang/Object;)Z
 201  */
 202 s4 _Jv_java_lang_Class_isInstance(java_lang_Class *klass, java_lang_Object *o)
 203 {
 204         classinfo     *c;
 205         java_handle_t *ob;
 206
 207         c = (classinfo *) klass;
 208         ob = (java_handle_t *) o;
 209
 210         if (!(c->state & CLASS_LINKED))
 211                 if (!link_class(c))
 212                         return 0;
 213
 214         return builtin_instanceof(ob, c);
 215 }
 216
 217
 218 /*
 219  * Class:     java/lang/Class
 220  * Method:    isAssignableFrom
 221  * Signature: (Ljava/lang/Class;)Z
 222  */
 223 s4 _Jv_java_lang_Class_isAssignableFrom(java_lang_Class *klass, java_lang_Class *c)
 224 {
 225         classinfo *kc;
 226         classinfo *cc;
 227
 228         kc = (classinfo *) klass;
 229         cc = (classinfo *) c;
 230
 231         if (cc == NULL) {
 232                 exceptions_throw_nullpointerexception();
 233                 return 0;
 234         }
 235
 236         if (!(kc->state & CLASS_LINKED))
 237                 if (!link_class(kc))
 238                         return 0;
 239
 240         if (!(cc->state & CLASS_LINKED))
 241                 if (!link_class(cc))
 242                         return 0;
 243
 244         return class_isanysubclass(cc, kc);
 245 }
 246
 247
 248 /*
 249  * Class:     java/lang/Class
 250  * Method:    isInterface
 251  * Signature: ()Z
 252  */
 253 JNIEXPORT int32_t JNICALL _Jv_java_lang_Class_isInterface(JNIEnv *env, java_lang_Class *this)
 254 {
 255         classinfo *c;
 256
 257         c = (classinfo *) this;
 258
 259         return class_is_interface(c);
 260 }
 261
 262
 263 #if defined(ENABLE_JAVASE)
 264
 265 /*
 266  * Class:     java/lang/Class
 267  * Method:    isPrimitive
 268  * Signature: ()Z
 269  */
 270 s4 _Jv_java_lang_Class_isPrimitive(java_lang_Class *klass)
 271 {
 272         classinfo *c;
 273
 274         c = (classinfo *) klass;
 275
 276         return class_is_primitive(c);
 277 }
 278
 279
 280 /*
 281  * Class:     java/lang/Class
 282  * Method:    getSuperclass
 283  * Signature: ()Ljava/lang/Class;
 284  */
 285 java_lang_Class *_Jv_java_lang_Class_getSuperclass(java_lang_Class *klass)
 286 {
 287         classinfo *c;
 288         classinfo *super;
 289
 290         c = (classinfo *) klass;
 291
 292         super = class_get_superclass(c);
 293
 294         return (java_lang_Class *) super;
 295 }
 296
 297
 298 /*
 299  * Class:     java/lang/Class
 300  * Method:    getInterfaces
 301  * Signature: ()[Ljava/lang/Class;
 302  */
 303 java_handle_objectarray_t *_Jv_java_lang_Class_getInterfaces(java_lang_Class *klass)
 304 {
 305         classinfo                 *c;
 306         java_handle_objectarray_t *oa;
 307
 308         c = (classinfo *) klass;
 309
 310         oa = class_get_interfaces(c);
 311
 312         return oa;
 313 }
 314
 315
 316 /*
 317  * Class:     java/lang/Class
 318  * Method:    getComponentType
 319  * Signature: ()Ljava/lang/Class;
 320  */
 321 java_lang_Class *_Jv_java_lang_Class_getComponentType(java_lang_Class *klass)
 322 {
 323         classinfo       *c;
 324         classinfo       *comp;
 325         arraydescriptor *desc;
 326
 327         c = (classinfo *) klass;
 328
 329         /* XXX maybe we could find a way to do this without linking. */
 330         /* This way should be safe and easy, however.                */
 331
 332         if (!(c->state & CLASS_LINKED))
 333                 if (!link_class(c))
 334                         return NULL;
 335
 336         desc = c->vftbl->arraydesc;
 337
 338         if (desc == NULL)
 339                 return NULL;
 340
 341         if (desc->arraytype == ARRAYTYPE_OBJECT)
 342                 comp = desc->componentvftbl->class;
 343         else
 344                 comp = primitive_class_get_by_type(desc->arraytype);
 345
 346         return (java_lang_Class *) comp;
 347 }
 348
 349
 350 /*
 351  * Class:     java/lang/Class
 352  * Method:    getModifiers
 353  * Signature: (Z)I
 354  */
 355 s4 _Jv_java_lang_Class_getModifiers(java_lang_Class *klass, s4 ignoreInnerClassesAttrib)
 356 {
 357         classinfo             *c;
 358         classref_or_classinfo  inner;
 359         classref_or_classinfo  outer;
 360         utf                   *innername;
 361         s4                     i;
 362
 363         c = (classinfo *) klass;
 364
 365         if (!ignoreInnerClassesAttrib && (c->innerclasscount != 0)) {
 366                 /* search for passed class as inner class */
 367
 368                 for (i = 0; i < c->innerclasscount; i++) {
 369                         inner = c->innerclass[i].inner_class;
 370                         outer = c->innerclass[i].outer_class;
 371
 372                         /* Check if inner is a classref or a real class and get
 373                the name of the structure */
 374
 375                         innername = IS_CLASSREF(inner) ? inner.ref->name : inner.cls->name;
 376
 377                         /* innerclass is this class */
 378
 379                         if (innername == c->name) {
 380                                 /* has the class actually an outer class? */
 381
 382                                 if (outer.any)
 383                                         /* return flags got from the outer class file */
 384                                         return c->innerclass[i].flags & ACC_CLASS_REFLECT_MASK;
 385                                 else
 386                                         return c->flags & ACC_CLASS_REFLECT_MASK;
 387                         }
 388                 }
 389         }
 390
 391         /* passed class is no inner class or it was not requested */
 392
 393         return c->flags & ACC_CLASS_REFLECT_MASK;
 394 }
 395
 396
 397 /*
 398  * Class:     java/lang/Class
 399  * Method:    getDeclaringClass
 400  * Signature: ()Ljava/lang/Class;
 401  */
 402 java_lang_Class *_Jv_java_lang_Class_getDeclaringClass(java_lang_Class *klass)
 403 {
 404         classinfo *c;
 405
 406         c = (classinfo *) klass;
 407
 408         return (java_lang_Class *) class_get_declaringclass(c);
 409 }
 410
 411
 412 /*
 413  * Class:     java/lang/Class
 414  * Method:    getDeclaredClasses
 415  * Signature: (Z)[Ljava/lang/Class;
 416  */
 417 java_handle_objectarray_t *_Jv_java_lang_Class_getDeclaredClasses(java_lang_Class *klass, s4 publicOnly)
 418 {
 419         classinfo                 *c;
 420         java_handle_objectarray_t *oa;
 421
 422         c = (classinfo *) klass;
 423
 424         oa = class_get_declaredclasses(c, publicOnly);
 425
 426         return oa;
 427 }
 428
 429
 430 /*
 431  * Class:     java/lang/Class
 432  * Method:    getDeclaredFields
 433  * Signature: (Z)[Ljava/lang/reflect/Field;
 434  */
 435 java_handle_objectarray_t *_Jv_java_lang_Class_getDeclaredFields(java_lang_Class *klass, s4 publicOnly)
 436 {
 437         classinfo                 *c;
 438         java_handle_objectarray_t *oa;          /* result: array of field-objects */
 439         fieldinfo                 *f;
 440         java_lang_reflect_Field   *rf;
 441         s4 public_fields;                    /* number of elements in field-array */
 442         s4 pos;
 443         s4 i;
 444
 445         c = (classinfo *) klass;
 446
 447         /* determine number of fields */
 448
 449         for (i = 0, public_fields = 0; i < c->fieldscount; i++)
 450                 if ((c->fields[i].flags & ACC_PUBLIC) || (publicOnly == 0))
 451                         public_fields++;
 452
 453         /* create array of fields */
 454
 455         oa = builtin_anewarray(public_fields, class_java_lang_reflect_Field);
 456
 457         if (oa == NULL)
 458                 return NULL;
 459
 460         /* get the fields and store in the array */
 461
 462         for (i = 0, pos = 0; i < c->fieldscount; i++) {
 463                 f = &(c->fields[i]);
 464
 465                 if ((f->flags & ACC_PUBLIC) || (publicOnly == 0)) {
 466                         /* create Field object */
 467
 468                         rf = reflect_field_new(f);
 469
 470                         /* store object into array */
 471
 472                         LLNI_objectarray_element_set(oa, pos, rf);
 473                         pos++;
 474                 }
 475         }
 476
 477         return oa;
 478 }
 479
 480
 481 /*
 482  * Class:     java/lang/Class
 483  * Method:    getDeclaredMethods
 484  * Signature: (Z)[Ljava/lang/reflect/Method;
 485  */
 486 java_handle_objectarray_t *_Jv_java_lang_Class_getDeclaredMethods(java_lang_Class *klass, s4 publicOnly)
 487 {
 488         classinfo                 *c;
 489         java_lang_reflect_Method  *rm;
 490         java_handle_objectarray_t *oa;         /* result: array of Method-objects */
 491         methodinfo                *m;     /* the current method to be represented */
 492         s4 public_methods;               /* number of public methods of the class */
 493         s4 pos;
 494         s4 i;
 495
 496         c = (classinfo *) klass;
 497
 498         public_methods = 0;
 499
 500         /* JOWENN: array classes do not declare methods according to mauve
 501            test.  It should be considered, if we should return to my old
 502            clone method overriding instead of declaring it as a member
 503            function. */
 504
 505         if (class_is_array(c))
 506                 return builtin_anewarray(0, class_java_lang_reflect_Method);
 507
 508         /* determine number of methods */
 509
 510         for (i = 0; i < c->methodscount; i++) {
 511                 m = &c->methods[i];
 512
 513                 if (((m->flags & ACC_PUBLIC) || (publicOnly == false)) &&
 514                         ((m->name != utf_init) && (m->name != utf_clinit)) &&
 515                         !(m->flags & ACC_MIRANDA))
 516                         public_methods++;
 517         }
 518
 519         oa = builtin_anewarray(public_methods, class_java_lang_reflect_Method);
 520
 521         if (oa == NULL)
 522                 return NULL;
 523
 524         for (i = 0, pos = 0; i < c->methodscount; i++) {
 525                 m = &c->methods[i];
 526
 527                 if (((m->flags & ACC_PUBLIC) || (publicOnly == false)) &&
 528                         ((m->name != utf_init) && (m->name != utf_clinit)) &&
 529                         !(m->flags & ACC_MIRANDA)) {
 530                         /* create Method object */
 531
 532                         rm = reflect_method_new(m);
 533
 534                         /* store object into array */
 535
 536                         LLNI_objectarray_element_set(oa, pos, rm);
 537                         pos++;
 538                 }
 539         }
 540
 541         return oa;
 542 }
 543
 544
 545 /*
 546  * Class:     java/lang/Class
 547  * Method:    getDeclaredConstructors
 548  * Signature: (Z)[Ljava/lang/reflect/Constructor;
 549  */
 550 java_handle_objectarray_t *_Jv_java_lang_Class_getDeclaredConstructors(java_lang_Class *klass, s4 publicOnly)
 551 {
 552         classinfo                     *c;
 553         methodinfo                    *m; /* the current method to be represented */
 554         java_handle_objectarray_t     *oa;     /* result: array of Method-objects */
 555         java_lang_reflect_Constructor *rc;
 556         s4 public_methods;               /* number of public methods of the class */
 557         s4 pos;
 558         s4 i;
 559
 560         c = (classinfo *) klass;
 561
 562         /* determine number of constructors */
 563
 564         for (i = 0, public_methods = 0; i < c->methodscount; i++) {
 565                 m = &c->methods[i];
 566
 567                 if (((m->flags & ACC_PUBLIC) || (publicOnly == 0)) &&
 568                         (m->name == utf_init))
 569                         public_methods++;
 570         }
 571
 572         oa = builtin_anewarray(public_methods, class_java_lang_reflect_Constructor);
 573
 574         if (oa == NULL)
 575                 return NULL;
 576
 577         for (i = 0, pos = 0; i < c->methodscount; i++) {
 578                 m = &c->methods[i];
 579
 580                 if (((m->flags & ACC_PUBLIC) || (publicOnly == 0)) &&
 581                         (m->name == utf_init)) {
 582                         /* create Constructor object */
 583
 584                         rc = reflect_constructor_new(m);
 585
 586                         /* store object into array */
 587
 588                         LLNI_objectarray_element_set(oa, pos, rc);
 589                         pos++;
 590                 }
 591         }
 592
 593         return oa;
 594 }
 595
 596
 597 /*
 598  * Class:     java/lang/Class
 599  * Method:    getClassLoader
 600  * Signature: ()Ljava/lang/ClassLoader;
 601  */
 602 java_lang_ClassLoader *_Jv_java_lang_Class_getClassLoader(java_lang_Class *klass)
 603 {
 604         classinfo *c;
 605
 606         c = (classinfo *) klass;
 607
 608         if (c->classloader == NULL)
 609                 return NULL;
 610         else
 611                 return (java_lang_ClassLoader *) c->classloader->object;
 612 }
 613
 614 #endif /* defined(ENABLE_JAVASE) */
 615
 616
 617 /*
 618  * Class:     java/lang/Class
 619  * Method:    isArray
 620  * Signature: ()Z
 621  */
 622 JNIEXPORT int32_t JNICALL _Jv_java_lang_Class_isArray(JNIEnv *env, java_lang_Class *this)
 623 {
 624         classinfo *c;
 625
 626         c = (classinfo *) this;
 627
 628         return class_is_array(c);
 629 }
 630
 631
 632 #if defined(ENABLE_JAVASE)
 633
 634 /*
 635  * Class:     java/lang/Class
 636  * Method:    throwException
 637  * Signature: (Ljava/lang/Throwable;)V
 638  */
 639 void _Jv_java_lang_Class_throwException(java_lang_Throwable *t)
 640 {
 641         java_handle_t *o;
 642
 643         o = (java_handle_t *) t;
 644
 645         exceptions_set_exception(o);
 646 }
 647
 648
 649 #if defined(WITH_CLASSPATH_GNU) && defined(ENABLE_ANNOTATIONS)
 650 /*
 651  * Class:     java/lang/Class
 652  * Method:    getDeclaredAnnotations
 653  * Signature: (Ljava/lang/Class;)[Ljava/lang/annotation/Annotation;
 654  */
 655 java_handle_objectarray_t *_Jv_java_lang_Class_getDeclaredAnnotations(java_lang_Class* klass)
 656 {
 657         classinfo                *c               = (classinfo*)klass;
 658         static methodinfo        *m_parseAnnotationsIntoArray   = NULL;
 659         utf                      *utf_parseAnnotationsIntoArray = NULL;
 660         utf                      *utf_desc        = NULL;
 661         java_handle_bytearray_t  *annotations     = NULL;
 662         sun_reflect_ConstantPool *constantPool    = NULL;
 663         uint32_t                  size            = 0;
 664         java_lang_Object         *constantPoolOop = (java_lang_Object*)klass;
 665
 666         if (c == NULL) {
 667                 exceptions_throw_nullpointerexception();
 668                 return NULL;
 669         }
 670
 671         /* Return null for arrays and primitives: */
 672         if (class_is_primitive(c) || class_is_array(c)) {
 673                 return NULL;
 674         }
 675
 676         if (c->annotations != NULL) {
 677                 size        = c->annotations->size;
 678                 annotations = builtin_newarray_byte(size);
 679
 680                 if(annotations != NULL) {
 681                         MCOPY(annotations->data, c->annotations->data, uint8_t, size);
 682                 }
 683         }
 684
 685         constantPool =
 686                 (sun_reflect_ConstantPool*)native_new_and_init(
 687                         class_sun_reflect_ConstantPool);
 688
 689         if(constantPool == NULL) {
 690                 /* out of memory */
 691                 return NULL;
 692         }
 693
 694         LLNI_field_set_ref(constantPool, constantPoolOop, constantPoolOop);
 695
 696         /* only resolve the method the first time */
 697         if (m_parseAnnotationsIntoArray == NULL) {
 698                 utf_parseAnnotationsIntoArray = utf_new_char("parseAnnotationsIntoArray");
 699                 utf_desc = utf_new_char(
 700                         "([BLsun/reflect/ConstantPool;Ljava/lang/Class;)"
 701                         "[Ljava/lang/annotation/Annotation;");
 702
 703                 if (utf_parseAnnotationsIntoArray == NULL || utf_desc == NULL) {
 704                         /* out of memory */
 705                         return NULL;
 706                 }
 707
 708                 m_parseAnnotationsIntoArray = class_resolveclassmethod(
 709                         class_sun_reflect_annotation_AnnotationParser,
 710                         utf_parseAnnotationsIntoArray,
 711                         utf_desc,
 712                         class_java_lang_Class,
 713                         true);
 714
 715                 if (m_parseAnnotationsIntoArray == NULL) {
 716                         /* method not found */
 717                         return NULL;
 718                 }
 719         }
 720
 721         return (java_handle_objectarray_t*)vm_call_method(
 722                 m_parseAnnotationsIntoArray, NULL,
 723                 annotations, constantPool, klass);
 724 }
 725 #endif
 726
 727
 728 /*
 729  * Class:     java/lang/Class
 730  * Method:    getEnclosingClass
 731  * Signature: (Ljava/lang/Class;)Ljava/lang/Class;
 732  */
 733 java_lang_Class *_Jv_java_lang_Class_getEnclosingClass(java_lang_Class *klass)
 734 {
 735         classinfo             *c;
 736         classref_or_classinfo  cr;
 737         classinfo             *ec;
 738
 739         c = (classinfo *) klass;
 740
 741         /* get enclosing class */
 742
 743         cr = c->enclosingclass;
 744
 745         if (cr.any == NULL)
 746                 return NULL;
 747
 748         /* resolve the class if necessary */
 749
 750         if (IS_CLASSREF(cr)) {
 751                 ec = resolve_classref_eager(cr.ref);
 752
 753                 if (ec == NULL)
 754                         return NULL;
 755         }
 756         else
 757                 ec = cr.cls;
 758
 759         return (java_lang_Class *) ec;
 760 }
 761
 762
 763 /* _Jv_java_lang_Class_getEnclosingMethod_intern *******************************
 764
 765    Helper function for _Jv_java_lang_Class_getEnclosingConstructor and
 766    _Jv_java_lang_Class_getEnclosingMethod.
 767
 768 *******************************************************************************/
 769
 770 static methodinfo *_Jv_java_lang_Class_getEnclosingMethod_intern(classinfo *c)
 771 {
 772         classref_or_classinfo     cr;
 773         constant_nameandtype     *cn;
 774         classinfo                *ec;
 775         methodinfo               *m;
 776
 777         /* get enclosing class and method */
 778
 779         cr = c->enclosingclass;
 780         cn = c->enclosingmethod;
 781
 782         /* check for enclosing class and method */
 783
 784         if (cr.any == NULL)
 785                 return NULL;
 786
 787         if (cn == NULL)
 788                 return NULL;
 789
 790         /* resolve the class if necessary */
 791
 792         if (IS_CLASSREF(cr)) {
 793                 ec = resolve_classref_eager(cr.ref);
 794
 795                 if (ec == NULL)
 796                         return NULL;
 797         }
 798         else
 799                 ec = cr.cls;
 800
 801         /* find method in enclosing class */
 802
 803         m = class_findmethod(ec, cn->name, cn->descriptor);
 804
 805         if (m == NULL) {
 806                 exceptions_throw_internalerror("Enclosing method doesn't exist");
 807                 return NULL;
 808         }
 809
 810         return m;
 811 }
 812
 813
 814 /*
 815  * Class:     java/lang/Class
 816  * Method:    getEnclosingConstructor
 817  * Signature: (Ljava/lang/Class;)Ljava/lang/reflect/Constructor;
 818  */
 819 java_lang_reflect_Constructor *_Jv_java_lang_Class_getEnclosingConstructor(java_lang_Class *klass)
 820 {
 821         classinfo                     *c;
 822         methodinfo                    *m;
 823         java_lang_reflect_Constructor *rc;
 824
 825         c = (classinfo *) klass;
 826
 827         /* get enclosing method */
 828
 829         m = _Jv_java_lang_Class_getEnclosingMethod_intern(c);
 830
 831         if (m == NULL)
 832                 return NULL;
 833
 834         /* check for <init> */
 835
 836         if (m->name != utf_init)
 837                 return NULL;
 838
 839         /* create Constructor object */
 840
 841         rc = reflect_constructor_new(m);
 842
 843         return rc;
 844 }
 845
 846
 847 /*
 848  * Class:     java/lang/Class
 849  * Method:    getEnclosingMethod
 850  * Signature: (Ljava/lang/Class;)Ljava/lang/reflect/Method;
 851  */
 852 java_lang_reflect_Method *_Jv_java_lang_Class_getEnclosingMethod(java_lang_Class *klass)
 853 {
 854         classinfo                *c;
 855         methodinfo               *m;
 856         java_lang_reflect_Method *rm;
 857
 858         c = (classinfo *) klass;
 859
 860         /* get enclosing method */
 861
 862         m = _Jv_java_lang_Class_getEnclosingMethod_intern(c);
 863
 864         if (m == NULL)
 865                 return NULL;
 866
 867         /* check for <init> */
 868
 869         if (m->name == utf_init)
 870                 return NULL;
 871
 872         /* create java.lang.reflect.Method object */
 873
 874         rm = reflect_method_new(m);
 875
 876         return rm;
 877 }
 878
 879
 880 /*
 881  * Class:     java/lang/Class
 882  * Method:    getClassSignature
 883  * Signature: (Ljava/lang/Class;)Ljava/lang/String;
 884  */
 885 java_lang_String *_Jv_java_lang_Class_getClassSignature(java_lang_Class* klass)
 886 {
 887         classinfo     *c;
 888         java_handle_t *o;
 889
 890         c = (classinfo *) klass;
 891
 892         if (c->signature == NULL)
 893                 return NULL;
 894
 895         o = javastring_new(c->signature);
 896
 897         /* in error case o is NULL */
 898
 899         return (java_lang_String *) o;
 900 }
 901
 902
 903 #if 0
 904 /*
 905  * Class:     java/lang/Class
 906  * Method:    isAnonymousClass
 907  * Signature: (Ljava/lang/Class;)Z
 908  */
 909 s4 _Jv_java_lang_Class_isAnonymousClass(JNIEnv *env, jclass clazz, struct java_lang_Class* par1);
 910
 911
 912 /*
 913  * Class:     java/lang/VMClass
 914  * Method:    isLocalClass
 915  * Signature: (Ljava/lang/Class;)Z
 916  */
 917 JNIEXPORT s4 JNICALL Java_java_lang_VMClass_isLocalClass(JNIEnv *env, jclass clazz, struct java_lang_Class* par1);
 918
 919
 920 /*
 921  * Class:     java/lang/VMClass
 922  * Method:    isMemberClass
 923  * Signature: (Ljava/lang/Class;)Z
 924  */
 925 JNIEXPORT s4 JNICALL Java_java_lang_VMClass_isMemberClass(JNIEnv *env, jclass clazz, struct java_lang_Class* par1);
 926 #endif
 927
 928 #endif /* ENABLE_JAVASE */
 929
 930
 931 /*
 932  * These are local overrides for various environment variables in Emacs.
 933  * Please do not remove this and leave it at the end of the file, where
 934  * Emacs will automagically detect them.
 935  * ---------------------------------------------------------------------
 936  * Local variables:
 937  * mode: c
 938  * indent-tabs-mode: t
 939  * c-basic-offset: 4
 940  * tab-width: 4
 941  * End:
 942  * vim:noexpandtab:sw=4:ts=4:
 943  */