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 8311 2007-08-15 17:03:40Z panzi $
  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   *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 < ca->header.size; i++) {
 116                 if (ca->data[i] == '/')
 117                         ca->data[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_objectarray *_Jv_java_lang_Class_getInterfaces(java_lang_Class *klass)
 304 {
 305         classinfo        *c;
 306         java_objectarray *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_objectarray *_Jv_java_lang_Class_getDeclaredClasses(java_lang_Class *klass, s4 publicOnly)
 418 {
 419         classinfo        *c;
 420         java_objectarray *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_objectarray *_Jv_java_lang_Class_getDeclaredFields(java_lang_Class *klass, s4 publicOnly)
 436 {
 437         classinfo               *c;
 438         java_objectarray        *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                         oa->data[pos++] = rf;
 473                 }
 474         }
 475
 476         return oa;
 477 }
 478
 479
 480 /*
 481  * Class:     java/lang/Class
 482  * Method:    getDeclaredMethods
 483  * Signature: (Z)[Ljava/lang/reflect/Method;
 484  */
 485 java_objectarray *_Jv_java_lang_Class_getDeclaredMethods(java_lang_Class *klass, s4 publicOnly)
 486 {
 487         classinfo                *c;
 488         java_lang_reflect_Method *rm;
 489         java_objectarray         *oa;          /* result: array of Method-objects */
 490         methodinfo               *m;      /* the current method to be represented */
 491         s4 public_methods;               /* number of public methods of the class */
 492         s4 pos;
 493         s4 i;
 494
 495         c = (classinfo *) klass;
 496
 497         public_methods = 0;
 498
 499         /* JOWENN: array classes do not declare methods according to mauve
 500            test.  It should be considered, if we should return to my old
 501            clone method overriding instead of declaring it as a member
 502            function. */
 503
 504         if (class_is_array(c))
 505                 return builtin_anewarray(0, class_java_lang_reflect_Method);
 506
 507         /* determine number of methods */
 508
 509         for (i = 0; i < c->methodscount; i++) {
 510                 m = &c->methods[i];
 511
 512                 if (((m->flags & ACC_PUBLIC) || (publicOnly == false)) &&
 513                         ((m->name != utf_init) && (m->name != utf_clinit)) &&
 514                         !(m->flags & ACC_MIRANDA))
 515                         public_methods++;
 516         }
 517
 518         oa = builtin_anewarray(public_methods, class_java_lang_reflect_Method);
 519
 520         if (oa == NULL)
 521                 return NULL;
 522
 523         for (i = 0, pos = 0; i < c->methodscount; i++) {
 524                 m = &c->methods[i];
 525
 526                 if (((m->flags & ACC_PUBLIC) || (publicOnly == false)) &&
 527                         ((m->name != utf_init) && (m->name != utf_clinit)) &&
 528                         !(m->flags & ACC_MIRANDA)) {
 529                         /* create Method object */
 530
 531                         rm = reflect_method_new(m);
 532
 533                         /* store object into array */
 534
 535                         oa->data[pos++] = rm;
 536                 }
 537         }
 538
 539         return oa;
 540 }
 541
 542
 543 /*
 544  * Class:     java/lang/Class
 545  * Method:    getDeclaredConstructors
 546  * Signature: (Z)[Ljava/lang/reflect/Constructor;
 547  */
 548 java_objectarray *_Jv_java_lang_Class_getDeclaredConstructors(java_lang_Class *klass, s4 publicOnly)
 549 {
 550         classinfo                     *c;
 551         methodinfo                    *m; /* the current method to be represented */
 552         java_objectarray              *oa;     /* result: array of Method-objects */
 553         java_lang_reflect_Constructor *rc;
 554         s4 public_methods;               /* number of public methods of the class */
 555         s4 pos;
 556         s4 i;
 557
 558         c = (classinfo *) klass;
 559
 560         /* determine number of constructors */
 561
 562         for (i = 0, public_methods = 0; i < c->methodscount; i++) {
 563                 m = &c->methods[i];
 564
 565                 if (((m->flags & ACC_PUBLIC) || (publicOnly == 0)) &&
 566                         (m->name == utf_init))
 567                         public_methods++;
 568         }
 569
 570         oa = builtin_anewarray(public_methods, class_java_lang_reflect_Constructor);
 571
 572         if (oa == NULL)
 573                 return NULL;
 574
 575         for (i = 0, pos = 0; i < c->methodscount; i++) {
 576                 m = &c->methods[i];
 577
 578                 if (((m->flags & ACC_PUBLIC) || (publicOnly == 0)) &&
 579                         (m->name == utf_init)) {
 580                         /* create Constructor object */
 581
 582                         rc = reflect_constructor_new(m);
 583
 584                         /* store object into array */
 585
 586                         oa->data[pos++] = rc;
 587                 }
 588         }
 589
 590         return oa;
 591 }
 592
 593
 594 /*
 595  * Class:     java/lang/Class
 596  * Method:    getClassLoader
 597  * Signature: ()Ljava/lang/ClassLoader;
 598  */
 599 java_lang_ClassLoader *_Jv_java_lang_Class_getClassLoader(java_lang_Class *klass)
 600 {
 601         classinfo *c;
 602
 603         c = (classinfo *) klass;
 604
 605         return (java_lang_ClassLoader *) c->classloader;
 606 }
 607
 608 #endif /* defined(ENABLE_JAVASE) */
 609
 610
 611 /*
 612  * Class:     java/lang/Class
 613  * Method:    isArray
 614  * Signature: ()Z
 615  */
 616 JNIEXPORT int32_t JNICALL _Jv_java_lang_Class_isArray(JNIEnv *env, java_lang_Class *this)
 617 {
 618         classinfo *c;
 619
 620         c = (classinfo *) this;
 621
 622         return class_is_array(c);
 623 }
 624
 625
 626 #if defined(ENABLE_JAVASE)
 627
 628 /*
 629  * Class:     java/lang/Class
 630  * Method:    throwException
 631  * Signature: (Ljava/lang/Throwable;)V
 632  */
 633 void _Jv_java_lang_Class_throwException(java_lang_Throwable *t)
 634 {
 635         java_handle_t *o;
 636
 637         o = (java_handle_t *) t;
 638
 639         exceptions_set_exception(o);
 640 }
 641
 642
 643 #if defined(WITH_CLASSPATH_GNU) && defined(ENABLE_ANNOTATIONS)
 644 /*
 645  * Class:     java/lang/Class
 646  * Method:    getDeclaredAnnotations
 647  * Signature: (Ljava/lang/Class;)[Ljava/lang/annotation/Annotation;
 648  */
 649 java_objectarray *_Jv_java_lang_Class_getDeclaredAnnotations(java_lang_Class* klass)
 650 {
 651         classinfo                *c               = (classinfo*)klass;
 652         static methodinfo        *m_parseAnnotationsIntoArray   = NULL;
 653         utf                      *utf_parseAnnotationsIntoArray = NULL;
 654         utf                      *utf_desc        = NULL;
 655         java_bytearray           *annotations     = NULL;
 656         sun_reflect_ConstantPool *constantPool    = NULL;
 657         uint32_t                  size            = 0;
 658         java_lang_Object         *constantPoolOop = (java_lang_Object*)klass;
 659
 660         if (c == NULL) {
 661                 exceptions_throw_nullpointerexception();
 662                 return NULL;
 663         }
 664
 665         /* Return null for arrays and primitives: */
 666         if (class_is_primitive(c) || class_is_array(c)) {
 667                 return NULL;
 668         }
 669
 670         if (c->annotations != NULL) {
 671                 size        = c->annotations->size;
 672                 annotations = builtin_newarray_byte(size);
 673
 674                 if(annotations != NULL) {
 675                         MCOPY(annotations->data, c->annotations->data, uint8_t, size);
 676                 }
 677         }
 678
 679         constantPool =
 680                 (sun_reflect_ConstantPool*)native_new_and_init(
 681                         class_sun_reflect_ConstantPool);
 682
 683         if(constantPool == NULL) {
 684                 /* out of memory */
 685                 return NULL;
 686         }
 687
 688         LLNI_field_set_ref(constantPool, constantPoolOop, constantPoolOop);
 689
 690         /* only resolve the method the first time */
 691         if (m_parseAnnotationsIntoArray == NULL) {
 692                 utf_parseAnnotationsIntoArray = utf_new_char("parseAnnotationsIntoArray");
 693                 utf_desc = utf_new_char(
 694                         "([BLsun/reflect/ConstantPool;Ljava/lang/Class;)"
 695                         "[Ljava/lang/annotation/Annotation;");
 696
 697                 if (utf_parseAnnotationsIntoArray == NULL || utf_desc == NULL) {
 698                         /* out of memory */
 699                         return NULL;
 700                 }
 701
 702                 m_parseAnnotationsIntoArray = class_resolveclassmethod(
 703                         class_sun_reflect_annotation_AnnotationParser,
 704                         utf_parseAnnotationsIntoArray,
 705                         utf_desc,
 706                         class_java_lang_Class,
 707                         true);
 708
 709                 if (m_parseAnnotationsIntoArray == NULL) {
 710                         /* method not found */
 711                         return NULL;
 712                 }
 713         }
 714
 715         return (java_objectarray*)vm_call_method(
 716                 m_parseAnnotationsIntoArray, NULL,
 717                 annotations, constantPool, klass);
 718 }
 719 #endif
 720
 721
 722 /*
 723  * Class:     java/lang/Class
 724  * Method:    getEnclosingClass
 725  * Signature: (Ljava/lang/Class;)Ljava/lang/Class;
 726  */
 727 java_lang_Class *_Jv_java_lang_Class_getEnclosingClass(java_lang_Class *klass)
 728 {
 729         classinfo             *c;
 730         classref_or_classinfo  cr;
 731         classinfo             *ec;
 732
 733         c = (classinfo *) klass;
 734
 735         /* get enclosing class */
 736
 737         cr = c->enclosingclass;
 738
 739         if (cr.any == NULL)
 740                 return NULL;
 741
 742         /* resolve the class if necessary */
 743
 744         if (IS_CLASSREF(cr)) {
 745                 ec = resolve_classref_eager(cr.ref);
 746
 747                 if (ec == NULL)
 748                         return NULL;
 749         }
 750         else
 751                 ec = cr.cls;
 752
 753         return (java_lang_Class *) ec;
 754 }
 755
 756
 757 /* _Jv_java_lang_Class_getEnclosingMethod_intern *******************************
 758
 759    Helper function for _Jv_java_lang_Class_getEnclosingConstructor and
 760    _Jv_java_lang_Class_getEnclosingMethod.
 761
 762 *******************************************************************************/
 763
 764 static methodinfo *_Jv_java_lang_Class_getEnclosingMethod_intern(classinfo *c)
 765 {
 766         classref_or_classinfo     cr;
 767         constant_nameandtype     *cn;
 768         classinfo                *ec;
 769         methodinfo               *m;
 770
 771         /* get enclosing class and method */
 772
 773         cr = c->enclosingclass;
 774         cn = c->enclosingmethod;
 775
 776         /* check for enclosing class and method */
 777
 778         if (cr.any == NULL)
 779                 return NULL;
 780
 781         if (cn == NULL)
 782                 return NULL;
 783
 784         /* resolve the class if necessary */
 785
 786         if (IS_CLASSREF(cr)) {
 787                 ec = resolve_classref_eager(cr.ref);
 788
 789                 if (ec == NULL)
 790                         return NULL;
 791         }
 792         else
 793                 ec = cr.cls;
 794
 795         /* find method in enclosing class */
 796
 797         m = class_findmethod(ec, cn->name, cn->descriptor);
 798
 799         if (m == NULL) {
 800                 exceptions_throw_internalerror("Enclosing method doesn't exist");
 801                 return NULL;
 802         }
 803
 804         return m;
 805 }
 806
 807
 808 /*
 809  * Class:     java/lang/Class
 810  * Method:    getEnclosingConstructor
 811  * Signature: (Ljava/lang/Class;)Ljava/lang/reflect/Constructor;
 812  */
 813 java_lang_reflect_Constructor *_Jv_java_lang_Class_getEnclosingConstructor(java_lang_Class *klass)
 814 {
 815         classinfo                     *c;
 816         methodinfo                    *m;
 817         java_lang_reflect_Constructor *rc;
 818
 819         c = (classinfo *) klass;
 820
 821         /* get enclosing method */
 822
 823         m = _Jv_java_lang_Class_getEnclosingMethod_intern(c);
 824
 825         if (m == NULL)
 826                 return NULL;
 827
 828         /* check for <init> */
 829
 830         if (m->name != utf_init)
 831                 return NULL;
 832
 833         /* create Constructor object */
 834
 835         rc = reflect_constructor_new(m);
 836
 837         return rc;
 838 }
 839
 840
 841 /*
 842  * Class:     java/lang/Class
 843  * Method:    getEnclosingMethod
 844  * Signature: (Ljava/lang/Class;)Ljava/lang/reflect/Method;
 845  */
 846 java_lang_reflect_Method *_Jv_java_lang_Class_getEnclosingMethod(java_lang_Class *klass)
 847 {
 848         classinfo                *c;
 849         methodinfo               *m;
 850         java_lang_reflect_Method *rm;
 851
 852         c = (classinfo *) klass;
 853
 854         /* get enclosing method */
 855
 856         m = _Jv_java_lang_Class_getEnclosingMethod_intern(c);
 857
 858         if (m == NULL)
 859                 return NULL;
 860
 861         /* check for <init> */
 862
 863         if (m->name == utf_init)
 864                 return NULL;
 865
 866         /* create java.lang.reflect.Method object */
 867
 868         rm = reflect_method_new(m);
 869
 870         return rm;
 871 }
 872
 873
 874 /*
 875  * Class:     java/lang/Class
 876  * Method:    getClassSignature
 877  * Signature: (Ljava/lang/Class;)Ljava/lang/String;
 878  */
 879 java_lang_String *_Jv_java_lang_Class_getClassSignature(java_lang_Class* klass)
 880 {
 881         classinfo     *c;
 882         java_handle_t *o;
 883
 884         c = (classinfo *) klass;
 885
 886         if (c->signature == NULL)
 887                 return NULL;
 888
 889         o = javastring_new(c->signature);
 890
 891         /* in error case o is NULL */
 892
 893         return (java_lang_String *) o;
 894 }
 895
 896
 897 #if 0
 898 /*
 899  * Class:     java/lang/Class
 900  * Method:    isAnonymousClass
 901  * Signature: (Ljava/lang/Class;)Z
 902  */
 903 s4 _Jv_java_lang_Class_isAnonymousClass(JNIEnv *env, jclass clazz, struct java_lang_Class* par1);
 904
 905
 906 /*
 907  * Class:     java/lang/VMClass
 908  * Method:    isLocalClass
 909  * Signature: (Ljava/lang/Class;)Z
 910  */
 911 JNIEXPORT s4 JNICALL Java_java_lang_VMClass_isLocalClass(JNIEnv *env, jclass clazz, struct java_lang_Class* par1);
 912
 913
 914 /*
 915  * Class:     java/lang/VMClass
 916  * Method:    isMemberClass
 917  * Signature: (Ljava/lang/Class;)Z
 918  */
 919 JNIEXPORT s4 JNICALL Java_java_lang_VMClass_isMemberClass(JNIEnv *env, jclass clazz, struct java_lang_Class* par1);
 920 #endif
 921
 922 #endif /* ENABLE_JAVASE */
 923
 924
 925 /*
 926  * These are local overrides for various environment variables in Emacs.
 927  * Please do not remove this and leave it at the end of the file, where
 928  * Emacs will automagically detect them.
 929  * ---------------------------------------------------------------------
 930  * Local variables:
 931  * mode: c
 932  * indent-tabs-mode: t
 933  * c-basic-offset: 4
 934  * tab-width: 4
 935  * End:
 936  * vim:noexpandtab:sw=4:ts=4:
 937  */