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 8318 2007-08-16 10:05:34Z 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_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 = (classloader *) 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                         pos++;
 473                         LLNI_objectarray_element_set(oa, pos, rf);
 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                         pos++;
 537                         LLNI_objectarray_element_set(oa, pos, rm);
 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                         pos++;
 589                         LLNI_objectarray_element_set(oa, pos, rc);
 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         return (java_lang_ClassLoader *) c->classloader;
 609 }
 610
 611 #endif /* defined(ENABLE_JAVASE) */
 612
 613
 614 /*
 615  * Class:     java/lang/Class
 616  * Method:    isArray
 617  * Signature: ()Z
 618  */
 619 JNIEXPORT int32_t JNICALL _Jv_java_lang_Class_isArray(JNIEnv *env, java_lang_Class *this)
 620 {
 621         classinfo *c;
 622
 623         c = (classinfo *) this;
 624
 625         return class_is_array(c);
 626 }
 627
 628
 629 #if defined(ENABLE_JAVASE)
 630
 631 /*
 632  * Class:     java/lang/Class
 633  * Method:    throwException
 634  * Signature: (Ljava/lang/Throwable;)V
 635  */
 636 void _Jv_java_lang_Class_throwException(java_lang_Throwable *t)
 637 {
 638         java_handle_t *o;
 639
 640         o = (java_handle_t *) t;
 641
 642         exceptions_set_exception(o);
 643 }
 644
 645
 646 #if defined(WITH_CLASSPATH_GNU) && defined(ENABLE_ANNOTATIONS)
 647 /*
 648  * Class:     java/lang/Class
 649  * Method:    getDeclaredAnnotations
 650  * Signature: (Ljava/lang/Class;)[Ljava/lang/annotation/Annotation;
 651  */
 652 java_handle_objectarray_t *_Jv_java_lang_Class_getDeclaredAnnotations(java_lang_Class* klass)
 653 {
 654         classinfo                *c               = (classinfo*)klass;
 655         static methodinfo        *m_parseAnnotationsIntoArray   = NULL;
 656         utf                      *utf_parseAnnotationsIntoArray = NULL;
 657         utf                      *utf_desc        = NULL;
 658         java_handle_bytearray_t  *annotations     = NULL;
 659         sun_reflect_ConstantPool *constantPool    = NULL;
 660         uint32_t                  size            = 0;
 661         java_lang_Object         *constantPoolOop = (java_lang_Object*)klass;
 662
 663         if (c == NULL) {
 664                 exceptions_throw_nullpointerexception();
 665                 return NULL;
 666         }
 667
 668         /* Return null for arrays and primitives: */
 669         if (class_is_primitive(c) || class_is_array(c)) {
 670                 return NULL;
 671         }
 672
 673         if (c->annotations != NULL) {
 674                 size        = c->annotations->size;
 675                 annotations = builtin_newarray_byte(size);
 676
 677                 if(annotations != NULL) {
 678                         MCOPY(annotations->data, c->annotations->data, uint8_t, size);
 679                 }
 680         }
 681
 682         constantPool =
 683                 (sun_reflect_ConstantPool*)native_new_and_init(
 684                         class_sun_reflect_ConstantPool);
 685
 686         if(constantPool == NULL) {
 687                 /* out of memory */
 688                 return NULL;
 689         }
 690
 691         LLNI_field_set_ref(constantPool, constantPoolOop, constantPoolOop);
 692
 693         /* only resolve the method the first time */
 694         if (m_parseAnnotationsIntoArray == NULL) {
 695                 utf_parseAnnotationsIntoArray = utf_new_char("parseAnnotationsIntoArray");
 696                 utf_desc = utf_new_char(
 697                         "([BLsun/reflect/ConstantPool;Ljava/lang/Class;)"
 698                         "[Ljava/lang/annotation/Annotation;");
 699
 700                 if (utf_parseAnnotationsIntoArray == NULL || utf_desc == NULL) {
 701                         /* out of memory */
 702                         return NULL;
 703                 }
 704
 705                 m_parseAnnotationsIntoArray = class_resolveclassmethod(
 706                         class_sun_reflect_annotation_AnnotationParser,
 707                         utf_parseAnnotationsIntoArray,
 708                         utf_desc,
 709                         class_java_lang_Class,
 710                         true);
 711
 712                 if (m_parseAnnotationsIntoArray == NULL) {
 713                         /* method not found */
 714                         return NULL;
 715                 }
 716         }
 717
 718         return (java_handle_objectarray_t*)vm_call_method(
 719                 m_parseAnnotationsIntoArray, NULL,
 720                 annotations, constantPool, klass);
 721 }
 722 #endif
 723
 724
 725 /*
 726  * Class:     java/lang/Class
 727  * Method:    getEnclosingClass
 728  * Signature: (Ljava/lang/Class;)Ljava/lang/Class;
 729  */
 730 java_lang_Class *_Jv_java_lang_Class_getEnclosingClass(java_lang_Class *klass)
 731 {
 732         classinfo             *c;
 733         classref_or_classinfo  cr;
 734         classinfo             *ec;
 735
 736         c = (classinfo *) klass;
 737
 738         /* get enclosing class */
 739
 740         cr = c->enclosingclass;
 741
 742         if (cr.any == NULL)
 743                 return NULL;
 744
 745         /* resolve the class if necessary */
 746
 747         if (IS_CLASSREF(cr)) {
 748                 ec = resolve_classref_eager(cr.ref);
 749
 750                 if (ec == NULL)
 751                         return NULL;
 752         }
 753         else
 754                 ec = cr.cls;
 755
 756         return (java_lang_Class *) ec;
 757 }
 758
 759
 760 /* _Jv_java_lang_Class_getEnclosingMethod_intern *******************************
 761
 762    Helper function for _Jv_java_lang_Class_getEnclosingConstructor and
 763    _Jv_java_lang_Class_getEnclosingMethod.
 764
 765 *******************************************************************************/
 766
 767 static methodinfo *_Jv_java_lang_Class_getEnclosingMethod_intern(classinfo *c)
 768 {
 769         classref_or_classinfo     cr;
 770         constant_nameandtype     *cn;
 771         classinfo                *ec;
 772         methodinfo               *m;
 773
 774         /* get enclosing class and method */
 775
 776         cr = c->enclosingclass;
 777         cn = c->enclosingmethod;
 778
 779         /* check for enclosing class and method */
 780
 781         if (cr.any == NULL)
 782                 return NULL;
 783
 784         if (cn == NULL)
 785                 return NULL;
 786
 787         /* resolve the class if necessary */
 788
 789         if (IS_CLASSREF(cr)) {
 790                 ec = resolve_classref_eager(cr.ref);
 791
 792                 if (ec == NULL)
 793                         return NULL;
 794         }
 795         else
 796                 ec = cr.cls;
 797
 798         /* find method in enclosing class */
 799
 800         m = class_findmethod(ec, cn->name, cn->descriptor);
 801
 802         if (m == NULL) {
 803                 exceptions_throw_internalerror("Enclosing method doesn't exist");
 804                 return NULL;
 805         }
 806
 807         return m;
 808 }
 809
 810
 811 /*
 812  * Class:     java/lang/Class
 813  * Method:    getEnclosingConstructor
 814  * Signature: (Ljava/lang/Class;)Ljava/lang/reflect/Constructor;
 815  */
 816 java_lang_reflect_Constructor *_Jv_java_lang_Class_getEnclosingConstructor(java_lang_Class *klass)
 817 {
 818         classinfo                     *c;
 819         methodinfo                    *m;
 820         java_lang_reflect_Constructor *rc;
 821
 822         c = (classinfo *) klass;
 823
 824         /* get enclosing method */
 825
 826         m = _Jv_java_lang_Class_getEnclosingMethod_intern(c);
 827
 828         if (m == NULL)
 829                 return NULL;
 830
 831         /* check for <init> */
 832
 833         if (m->name != utf_init)
 834                 return NULL;
 835
 836         /* create Constructor object */
 837
 838         rc = reflect_constructor_new(m);
 839
 840         return rc;
 841 }
 842
 843
 844 /*
 845  * Class:     java/lang/Class
 846  * Method:    getEnclosingMethod
 847  * Signature: (Ljava/lang/Class;)Ljava/lang/reflect/Method;
 848  */
 849 java_lang_reflect_Method *_Jv_java_lang_Class_getEnclosingMethod(java_lang_Class *klass)
 850 {
 851         classinfo                *c;
 852         methodinfo               *m;
 853         java_lang_reflect_Method *rm;
 854
 855         c = (classinfo *) klass;
 856
 857         /* get enclosing method */
 858
 859         m = _Jv_java_lang_Class_getEnclosingMethod_intern(c);
 860
 861         if (m == NULL)
 862                 return NULL;
 863
 864         /* check for <init> */
 865
 866         if (m->name == utf_init)
 867                 return NULL;
 868
 869         /* create java.lang.reflect.Method object */
 870
 871         rm = reflect_method_new(m);
 872
 873         return rm;
 874 }
 875
 876
 877 /*
 878  * Class:     java/lang/Class
 879  * Method:    getClassSignature
 880  * Signature: (Ljava/lang/Class;)Ljava/lang/String;
 881  */
 882 java_lang_String *_Jv_java_lang_Class_getClassSignature(java_lang_Class* klass)
 883 {
 884         classinfo     *c;
 885         java_handle_t *o;
 886
 887         c = (classinfo *) klass;
 888
 889         if (c->signature == NULL)
 890                 return NULL;
 891
 892         o = javastring_new(c->signature);
 893
 894         /* in error case o is NULL */
 895
 896         return (java_lang_String *) o;
 897 }
 898
 899
 900 #if 0
 901 /*
 902  * Class:     java/lang/Class
 903  * Method:    isAnonymousClass
 904  * Signature: (Ljava/lang/Class;)Z
 905  */
 906 s4 _Jv_java_lang_Class_isAnonymousClass(JNIEnv *env, jclass clazz, struct java_lang_Class* par1);
 907
 908
 909 /*
 910  * Class:     java/lang/VMClass
 911  * Method:    isLocalClass
 912  * Signature: (Ljava/lang/Class;)Z
 913  */
 914 JNIEXPORT s4 JNICALL Java_java_lang_VMClass_isLocalClass(JNIEnv *env, jclass clazz, struct java_lang_Class* par1);
 915
 916
 917 /*
 918  * Class:     java/lang/VMClass
 919  * Method:    isMemberClass
 920  * Signature: (Ljava/lang/Class;)Z
 921  */
 922 JNIEXPORT s4 JNICALL Java_java_lang_VMClass_isMemberClass(JNIEnv *env, jclass clazz, struct java_lang_Class* par1);
 923 #endif
 924
 925 #endif /* ENABLE_JAVASE */
 926
 927
 928 /*
 929  * These are local overrides for various environment variables in Emacs.
 930  * Please do not remove this and leave it at the end of the file, where
 931  * Emacs will automagically detect them.
 932  * ---------------------------------------------------------------------
 933  * Local variables:
 934  * mode: c
 935  * indent-tabs-mode: t
 936  * c-basic-offset: 4
 937  * tab-width: 4
 938  * End:
 939  * vim:noexpandtab:sw=4:ts=4:
 940  */