libjava/java/lang/Class.java

   1 /* Class.java -- Representation of a Java class.
   2    Copyright (C) 1998, 1999, 2000, 2002, 2003, 2004, 2005
   3    Free Software Foundation
   4
   5 This file is part of GNU Classpath.
   6
   7 GNU Classpath is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU Classpath is distributed in the hope that it will be useful, but
  13 WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU Classpath; see the file COPYING.  If not, write to the
  19 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  20 02110-1301 USA.
  21
  22 Linking this library statically or dynamically with other modules is
  23 making a combined work based on this library.  Thus, the terms and
  24 conditions of the GNU General Public License cover the whole
  25 combination.
  26
  27 As a special exception, the copyright holders of this library give you
  28 permission to link this library with independent modules to produce an
  29 executable, regardless of the license terms of these independent
  30 modules, and to copy and distribute the resulting executable under
  31 terms of your choice, provided that you also meet, for each linked
  32 independent module, the terms and conditions of the license of that
  33 module.  An independent module is a module which is not derived from
  34 or based on this library.  If you modify this library, you may extend
  35 this exception to your version of the library, but you are not
  36 obligated to do so.  If you do not wish to do so, delete this
  37 exception statement from your version. */
  38
  39 package java.lang;
  40
  41 import java.io.InputStream;
  42 import java.io.Serializable;
  43 import java.lang.reflect.Constructor;
  44 import java.lang.reflect.Field;
  45 import java.lang.reflect.Member;
  46 import java.lang.reflect.Method;
  47 import java.net.URL;
  48 import java.security.ProtectionDomain;
  49 import java.util.ArrayList;
  50 import java.util.Arrays;
  51 import java.util.HashSet;
  52
  53 /**
  54  * A Class represents a Java type.  There will never be multiple Class
  55  * objects with identical names and ClassLoaders. Primitive types, array
  56  * types, and void also have a Class object.
  57  *
  58  * <p>Arrays with identical type and number of dimensions share the same class.
  59  * The array class ClassLoader is the same as the ClassLoader of the element
  60  * type of the array (which can be null to indicate the bootstrap classloader).
  61  * The name of an array class is <code>[&lt;signature format&gt;;</code>.
  62  * <p> For example,
  63  * String[]'s class is <code>[Ljava.lang.String;</code>. boolean, byte,
  64  * short, char, int, long, float and double have the "type name" of
  65  * Z,B,S,C,I,J,F,D for the purposes of array classes.  If it's a
  66  * multidimensioned array, the same principle applies:
  67  * <code>int[][][]</code> == <code>[[[I</code>.
  68  *
  69  * <p>There is no public constructor - Class objects are obtained only through
  70  * the virtual machine, as defined in ClassLoaders.
  71  *
  72  * @serialData Class objects serialize specially:
  73  * <code>TC_CLASS ClassDescriptor</code>. For more serialization information,
  74  * see {@link ObjectStreamClass}.
  75  *
  76  * @author John Keiser
  77  * @author Eric Blake (ebb9@email.byu.edu)
  78  * @author Tom Tromey (tromey@cygnus.com)
  79  * @since 1.0
  80  * @see ClassLoader
  81  */
  82 public final class Class implements Serializable
  83 {
  84   /**
  85    * Class is non-instantiable from Java code; only the VM can create
  86    * instances of this class.
  87    */
  88   private Class ()
  89   {
  90   }
  91
  92   // Initialize the class.
  93   private native void initializeClass ();
  94
  95   // finalization
  96   protected native void finalize () throws Throwable;
  97
  98   /**
  99    * Use the classloader of the current class to load, link, and initialize
 100    * a class. This is equivalent to your code calling
 101    * <code>Class.forName(name, true, getClass().getClassLoader())</code>.
 102    *
 103    * @param name the name of the class to find
 104    * @return the Class object representing the class
 105    * @throws ClassNotFoundException if the class was not found by the
 106    *         classloader
 107    * @throws LinkageError if linking the class fails
 108    * @throws ExceptionInInitializerError if the class loads, but an exception
 109    *         occurs during initialization
 110    */
 111   public static native Class forName (String className)
 112     throws ClassNotFoundException;
 113
 114   /**
 115    * Use the specified classloader to load and link a class. If the loader
 116    * is null, this uses the bootstrap class loader (provide the security
 117    * check succeeds). Unfortunately, this method cannot be used to obtain
 118    * the Class objects for primitive types or for void, you have to use
 119    * the fields in the appropriate java.lang wrapper classes.
 120    *
 121    * <p>Calls <code>classloader.loadclass(name, initialize)</code>.
 122    *
 123    * @param name the name of the class to find
 124    * @param initialize whether or not to initialize the class at this time
 125    * @param classloader the classloader to use to find the class; null means
 126    *        to use the bootstrap class loader
 127    * @throws ClassNotFoundException if the class was not found by the
 128    *         classloader
 129    * @throws LinkageError if linking the class fails
 130    * @throws ExceptionInInitializerError if the class loads, but an exception
 131    *         occurs during initialization
 132    * @throws SecurityException if the <code>classloader</code> argument
 133    *         is <code>null</code> and the caller does not have the
 134    *         <code>RuntimePermission("getClassLoader")</code> permission
 135    * @see ClassLoader
 136    * @since 1.2
 137    */
 138   public static native Class forName (String className, boolean initialize,
 139                                       ClassLoader loader)
 140     throws ClassNotFoundException;
 141
 142   /**
 143    * Get all the public member classes and interfaces declared in this
 144    * class or inherited from superclasses. This returns an array of length
 145    * 0 if there are no member classes, including for primitive types. A
 146    * security check may be performed, with
 147    * <code>checkMemberAccess(this, Member.PUBLIC)</code> as well as
 148    * <code>checkPackageAccess</code> both having to succeed.
 149    *
 150    * @return all public member classes in this class
 151    * @throws SecurityException if the security check fails
 152    * @since 1.1
 153    */
 154   public Class[] getClasses()
 155   {
 156     memberAccessCheck(Member.PUBLIC);
 157     return internalGetClasses();
 158   }
 159
 160   /**
 161    * Like <code>getClasses()</code> but without the security checks.
 162    */
 163   private Class[] internalGetClasses()
 164   {
 165     ArrayList list = new ArrayList();
 166     list.addAll(Arrays.asList(getDeclaredClasses(true)));
 167     Class superClass = getSuperclass();
 168     if (superClass != null)
 169       list.addAll(Arrays.asList(superClass.internalGetClasses()));
 170     return (Class[])list.toArray(new Class[list.size()]);
 171   }
 172
 173   /**
 174    * Get the ClassLoader that loaded this class.  If the class was loaded
 175    * by the bootstrap classloader, this method will return null.
 176    * If there is a security manager, and the caller's class loader is not
 177    * an ancestor of the requested one, a security check of
 178    * <code>RuntimePermission("getClassLoader")</code>
 179    * must first succeed. Primitive types and void return null.
 180    *
 181    * @return the ClassLoader that loaded this class
 182    * @throws SecurityException if the security check fails
 183    * @see ClassLoader
 184    * @see RuntimePermission
 185    */
 186   public native ClassLoader getClassLoader ();
 187
 188   /**
 189    * If this is an array, get the Class representing the type of array.
 190    * Examples: "[[Ljava.lang.String;" would return "[Ljava.lang.String;", and
 191    * calling getComponentType on that would give "java.lang.String".  If
 192    * this is not an array, returns null.
 193    *
 194    * @return the array type of this class, or null
 195    * @see Array
 196    * @since 1.1
 197    */
 198   public native Class getComponentType ();
 199
 200   /**
 201    * Get a public constructor declared in this class. If the constructor takes
 202    * no argument, an array of zero elements and null are equivalent for the
 203    * types argument. A security check may be performed, with
 204    * <code>checkMemberAccess(this, Member.PUBLIC)</code> as well as
 205    * <code>checkPackageAccess</code> both having to succeed.
 206    *
 207    * @param types the type of each parameter
 208    * @return the constructor
 209    * @throws NoSuchMethodException if the constructor does not exist
 210    * @throws SecurityException if the security check fails
 211    * @see #getConstructors()
 212    * @since 1.1
 213    */
 214   public native Constructor getConstructor(Class[] args)
 215     throws NoSuchMethodException;
 216
 217   /**
 218    * Get all the public constructors of this class. This returns an array of
 219    * length 0 if there are no constructors, including for primitive types,
 220    * arrays, and interfaces. It does, however, include the default
 221    * constructor if one was supplied by the compiler. A security check may
 222    * be performed, with <code>checkMemberAccess(this, Member.PUBLIC)</code>
 223    * as well as <code>checkPackageAccess</code> both having to succeed.
 224    *
 225    * @return all public constructors in this class
 226    * @throws SecurityException if the security check fails
 227    * @since 1.1
 228    */
 229   public Constructor[] getConstructors()
 230   {
 231     memberAccessCheck(Member.PUBLIC);
 232     return getDeclaredConstructors(true);
 233   }
 234
 235   /**
 236    * Get a constructor declared in this class. If the constructor takes no
 237    * argument, an array of zero elements and null are equivalent for the
 238    * types argument. A security check may be performed, with
 239    * <code>checkMemberAccess(this, Member.DECLARED)</code> as well as
 240    * <code>checkPackageAccess</code> both having to succeed.
 241    *
 242    * @param types the type of each parameter
 243    * @return the constructor
 244    * @throws NoSuchMethodException if the constructor does not exist
 245    * @throws SecurityException if the security check fails
 246    * @see #getDeclaredConstructors()
 247    * @since 1.1
 248    */
 249   public native Constructor getDeclaredConstructor(Class[] args)
 250     throws NoSuchMethodException;
 251
 252   /**
 253    * Get all the declared member classes and interfaces in this class, but
 254    * not those inherited from superclasses. This returns an array of length
 255    * 0 if there are no member classes, including for primitive types. A
 256    * security check may be performed, with
 257    * <code>checkMemberAccess(this, Member.DECLARED)</code> as well as
 258    * <code>checkPackageAccess</code> both having to succeed.
 259    *
 260    * @return all declared member classes in this class
 261    * @throws SecurityException if the security check fails
 262    * @since 1.1
 263    */
 264   public Class[] getDeclaredClasses()
 265   {
 266     memberAccessCheck(Member.DECLARED);
 267     return getDeclaredClasses(false);
 268   }
 269
 270   native Class[] getDeclaredClasses (boolean publicOnly);
 271
 272   /**
 273    * Get all the declared constructors of this class. This returns an array of
 274    * length 0 if there are no constructors, including for primitive types,
 275    * arrays, and interfaces. It does, however, include the default
 276    * constructor if one was supplied by the compiler. A security check may
 277    * be performed, with <code>checkMemberAccess(this, Member.DECLARED)</code>
 278    * as well as <code>checkPackageAccess</code> both having to succeed.
 279    *
 280    * @return all constructors in this class
 281    * @throws SecurityException if the security check fails
 282    * @since 1.1
 283    */
 284   public Constructor[] getDeclaredConstructors()
 285   {
 286     memberAccessCheck(Member.DECLARED);
 287     return getDeclaredConstructors(false);
 288   }
 289
 290   native Constructor[] getDeclaredConstructors (boolean publicOnly);
 291
 292   /**
 293    * Get a field declared in this class, where name is its simple name. The
 294    * implicit length field of arrays is not available. A security check may
 295    * be performed, with <code>checkMemberAccess(this, Member.DECLARED)</code>
 296    * as well as <code>checkPackageAccess</code> both having to succeed.
 297    *
 298    * @param name the name of the field
 299    * @return the field
 300    * @throws NoSuchFieldException if the field does not exist
 301    * @throws SecurityException if the security check fails
 302    * @see #getDeclaredFields()
 303    * @since 1.1
 304    */
 305   public native Field getDeclaredField(String fieldName)
 306     throws NoSuchFieldException;
 307
 308   /**
 309    * Get all the declared fields in this class, but not those inherited from
 310    * superclasses. This returns an array of length 0 if there are no fields,
 311    * including for primitive types. This does not return the implicit length
 312    * field of arrays. A security check may be performed, with
 313    * <code>checkMemberAccess(this, Member.DECLARED)</code> as well as
 314    * <code>checkPackageAccess</code> both having to succeed.
 315    *
 316    * @return all declared fields in this class
 317    * @throws SecurityException if the security check fails
 318    * @since 1.1
 319    */
 320   public Field[] getDeclaredFields()
 321   {
 322     memberAccessCheck(Member.DECLARED);
 323     return getDeclaredFields(false);
 324   }
 325
 326   native Field[] getDeclaredFields (boolean publicOnly);
 327
 328   private native Method _getDeclaredMethod(String methodName, Class[] args);
 329
 330   /**
 331    * Get a method declared in this class, where name is its simple name. The
 332    * implicit methods of Object are not available from arrays or interfaces.
 333    * Constructors (named "&lt;init&gt;" in the class file) and class initializers
 334    * (name "&lt;clinit&gt;") are not available.  The Virtual Machine allows
 335    * multiple methods with the same signature but differing return types; in
 336    * such a case the most specific return types are favored, then the final
 337    * choice is arbitrary. If the method takes no argument, an array of zero
 338    * elements and null are equivalent for the types argument. A security
 339    * check may be performed, with
 340    * <code>checkMemberAccess(this, Member.DECLARED)</code> as well as
 341    * <code>checkPackageAccess</code> both having to succeed.
 342    *
 343    * @param methodName the name of the method
 344    * @param types the type of each parameter
 345    * @return the method
 346    * @throws NoSuchMethodException if the method does not exist
 347    * @throws SecurityException if the security check fails
 348    * @see #getDeclaredMethods()
 349    * @since 1.1
 350    */
 351   public Method getDeclaredMethod(String methodName, Class[] args)
 352     throws NoSuchMethodException
 353   {
 354     memberAccessCheck(Member.DECLARED);
 355
 356     if ("<init>".equals(methodName) || "<clinit>".equals(methodName))
 357       throw new NoSuchMethodException(methodName);
 358
 359     Method match = _getDeclaredMethod(methodName, args);
 360     if (match == null)
 361       throw new NoSuchMethodException(methodName);
 362     return match;
 363   }
 364
 365   /**
 366    * Get all the declared methods in this class, but not those inherited from
 367    * superclasses. This returns an array of length 0 if there are no methods,
 368    * including for primitive types. This does include the implicit methods of
 369    * arrays and interfaces which mirror methods of Object, nor does it
 370    * include constructors or the class initialization methods. The Virtual
 371    * Machine allows multiple methods with the same signature but differing
 372    * return types; all such methods are in the returned array. A security
 373    * check may be performed, with
 374    * <code>checkMemberAccess(this, Member.DECLARED)</code> as well as
 375    * <code>checkPackageAccess</code> both having to succeed.
 376    *
 377    * @return all declared methods in this class
 378    * @throws SecurityException if the security check fails
 379    * @since 1.1
 380    */
 381   public native Method[] getDeclaredMethods();
 382
 383   /**
 384    * If this is a nested or inner class, return the class that declared it.
 385    * If not, return null.
 386    *
 387    * @return the declaring class of this class
 388    * @since 1.1
 389    */
 390   // This is marked as unimplemented in the JCL book.
 391   public native Class getDeclaringClass ();
 392
 393   private native Field getField (String fieldName, int hash)
 394     throws NoSuchFieldException;
 395
 396   /**
 397    * Get a public field declared or inherited in this class, where name is
 398    * its simple name. If the class contains multiple accessible fields by
 399    * that name, an arbitrary one is returned. The implicit length field of
 400    * arrays is not available. A security check may be performed, with
 401    * <code>checkMemberAccess(this, Member.PUBLIC)</code> as well as
 402    * <code>checkPackageAccess</code> both having to succeed.
 403    *
 404    * @param fieldName the name of the field
 405    * @return the field
 406    * @throws NoSuchFieldException if the field does not exist
 407    * @throws SecurityException if the security check fails
 408    * @see #getFields()
 409    * @since 1.1
 410    */
 411   public Field getField(String fieldName)
 412     throws NoSuchFieldException
 413   {
 414     memberAccessCheck(Member.PUBLIC);
 415     Field field = getField(fieldName, fieldName.hashCode());
 416     if (field == null)
 417       throw new NoSuchFieldException(fieldName);
 418     return field;
 419   }
 420
 421   /**
 422    * Get all the public fields declared in this class or inherited from
 423    * superclasses. This returns an array of length 0 if there are no fields,
 424    * including for primitive types. This does not return the implicit length
 425    * field of arrays. A security check may be performed, with
 426    * <code>checkMemberAccess(this, Member.PUBLIC)</code> as well as
 427    * <code>checkPackageAccess</code> both having to succeed.
 428    *
 429    * @return all public fields in this class
 430    * @throws SecurityException if the security check fails
 431    * @since 1.1
 432    */
 433   public Field[] getFields()
 434   {
 435     memberAccessCheck(Member.PUBLIC);
 436     return internalGetFields();
 437   }
 438
 439   /**
 440    * Like <code>getFields()</code> but without the security checks.
 441    */
 442   private Field[] internalGetFields()
 443   {
 444     HashSet set = new HashSet();
 445     set.addAll(Arrays.asList(getDeclaredFields(true)));
 446     Class[] interfaces = getInterfaces();
 447     for (int i = 0; i < interfaces.length; i++)
 448       set.addAll(Arrays.asList(interfaces[i].internalGetFields()));
 449     Class superClass = getSuperclass();
 450     if (superClass != null)
 451       set.addAll(Arrays.asList(superClass.internalGetFields()));
 452     return (Field[])set.toArray(new Field[set.size()]);
 453   }
 454
 455   /**
 456    * Returns the <code>Package</code> in which this class is defined
 457    * Returns null when this information is not available from the
 458    * classloader of this class or when the classloader of this class
 459    * is null.
 460    *
 461    * @return the package for this class, if it is available
 462    * @since 1.2
 463    */
 464   public Package getPackage()
 465   {
 466     ClassLoader cl = getClassLoader();
 467     if (cl != null)
 468       return cl.getPackage(getPackagePortion(getName()));
 469     return null;
 470   }
 471
 472   /**
 473    * Get the interfaces this class <em>directly</em> implements, in the
 474    * order that they were declared. This returns an empty array, not null,
 475    * for Object, primitives, void, and classes or interfaces with no direct
 476    * superinterface. Array types return Cloneable and Serializable.
 477    *
 478    * @return the interfaces this class directly implements
 479    */
 480   public native Class[] getInterfaces ();
 481
 482   private final native void getSignature(StringBuffer buffer);
 483   private static final native String getSignature(Class[] args,
 484                                                   boolean is_construtor);
 485
 486   public native Method _getMethod(String methodName, Class[] args);
 487
 488   /**
 489    * Get a public method declared or inherited in this class, where name is
 490    * its simple name. The implicit methods of Object are not available from
 491    * interfaces.  Constructors (named "&lt;init&gt;" in the class file) and class
 492    * initializers (name "&lt;clinit&gt;") are not available.  The Virtual
 493    * Machine allows multiple methods with the same signature but differing
 494    * return types, and the class can inherit multiple methods of the same
 495    * return type; in such a case the most specific return types are favored,
 496    * then the final choice is arbitrary. If the method takes no argument, an
 497    * array of zero elements and null are equivalent for the types argument.
 498    * A security check may be performed, with
 499    * <code>checkMemberAccess(this, Member.PUBLIC)</code> as well as
 500    * <code>checkPackageAccess</code> both having to succeed.
 501    *
 502    * @param methodName the name of the method
 503    * @param types the type of each parameter
 504    * @return the method
 505    * @throws NoSuchMethodException if the method does not exist
 506    * @throws SecurityException if the security check fails
 507    * @see #getMethods()
 508    * @since 1.1
 509    */
 510   public Method getMethod(String methodName, Class[] args)
 511     throws NoSuchMethodException
 512   {
 513     memberAccessCheck(Member.PUBLIC);
 514
 515     if ("<init>".equals(methodName) || "<clinit>".equals(methodName))
 516       throw new NoSuchMethodException(methodName);
 517
 518     Method method = _getMethod(methodName, args);
 519     if (method == null)
 520       throw new NoSuchMethodException(methodName);
 521     return method;
 522   }
 523
 524   private native int _getMethods (Method[] result, int offset);
 525
 526   /**
 527    * Get all the public methods declared in this class or inherited from
 528    * superclasses. This returns an array of length 0 if there are no methods,
 529    * including for primitive types. This does not include the implicit
 530    * methods of interfaces which mirror methods of Object, nor does it
 531    * include constructors or the class initialization methods. The Virtual
 532    * Machine allows multiple methods with the same signature but differing
 533    * return types; all such methods are in the returned array. A security
 534    * check may be performed, with
 535    * <code>checkMemberAccess(this, Member.PUBLIC)</code> as well as
 536    * <code>checkPackageAccess</code> both having to succeed.
 537    *
 538    * @return all public methods in this class
 539    * @throws SecurityException if the security check fails
 540    * @since 1.1
 541    */
 542   public native Method[] getMethods();
 543
 544   /**
 545    * Get the modifiers of this class.  These can be decoded using Modifier,
 546    * and is limited to one of public, protected, or private, and any of
 547    * final, static, abstract, or interface. An array class has the same
 548    * public, protected, or private modifier as its component type, and is
 549    * marked final but not an interface. Primitive types and void are marked
 550    * public and final, but not an interface.
 551    *
 552    * @return the modifiers of this class
 553    * @see Modifer
 554    * @since 1.1
 555    */
 556   public native int getModifiers ();
 557
 558   /**
 559    * Get the name of this class, separated by dots for package separators.
 560    * If the class represents a primitive type, or void, then the
 561    * name of the type as it appears in the Java programming language
 562    * is returned.  For instance, <code>Byte.TYPE.getName()</code>
 563    * returns "byte".
 564    *
 565    * Arrays are specially encoded as shown on this table.
 566    * <pre>
 567    * array type          [<em>element type</em>
 568    *                     (note that the element type is encoded per
 569    *                      this table)
 570    * boolean             Z
 571    * byte                B
 572    * char                C
 573    * short               S
 574    * int                 I
 575    * long                J
 576    * float               F
 577    * double              D
 578    * void                V
 579    * class or interface, alone: &lt;dotted name&gt;
 580    * class or interface, as element type: L&lt;dotted name&gt;;
 581    * </pre>
 582    *
 583    * @return the name of this class
 584    */
 585   public native String getName ();
 586
 587   /**
 588    * Get a resource URL using this class's package using the
 589    * getClassLoader().getResource() method.  If this class was loaded using
 590    * the system classloader, ClassLoader.getSystemResource() is used instead.
 591    *
 592    * <p>If the name you supply is absolute (it starts with a <code>/</code>),
 593    * then the leading <code>/</code> is removed and it is passed on to
 594    * getResource(). If it is relative, the package name is prepended, and
 595    * <code>.</code>'s are replaced with <code>/</code>.
 596    *
 597    * <p>The URL returned is system- and classloader-dependent, and could
 598    * change across implementations.
 599    *
 600    * @param resourceName the name of the resource, generally a path
 601    * @return the URL to the resource
 602    * @throws NullPointerException if name is null
 603    * @since 1.1
 604    */
 605   public URL getResource(String resourceName)
 606   {
 607     String name = resourcePath(resourceName);
 608     ClassLoader loader = getClassLoader();
 609     if (loader == null)
 610       return ClassLoader.getSystemResource(name);
 611     return loader.getResource(name);
 612   }
 613
 614   /**
 615    * Get a resource using this class's package using the
 616    * getClassLoader().getResourceAsStream() method.  If this class was loaded
 617    * using the system classloader, ClassLoader.getSystemResource() is used
 618    * instead.
 619    *
 620    * <p>If the name you supply is absolute (it starts with a <code>/</code>),
 621    * then the leading <code>/</code> is removed and it is passed on to
 622    * getResource(). If it is relative, the package name is prepended, and
 623    * <code>.</code>'s are replaced with <code>/</code>.
 624    *
 625    * <p>The URL returned is system- and classloader-dependent, and could
 626    * change across implementations.
 627    *
 628    * @param resourceName the name of the resource, generally a path
 629    * @return an InputStream with the contents of the resource in it, or null
 630    * @throws NullPointerException if name is null
 631    * @since 1.1
 632    */
 633   public InputStream getResourceAsStream(String resourceName)
 634   {
 635     String name = resourcePath(resourceName);
 636     ClassLoader loader = getClassLoader();
 637     if (loader == null)
 638       return ClassLoader.getSystemResourceAsStream(name);
 639     return loader.getResourceAsStream(name);
 640   }
 641
 642   private String resourcePath(String resourceName)
 643   {
 644     if (resourceName.length() > 0)
 645       {
 646         if (resourceName.charAt(0) != '/')
 647           {
 648             String pkg = getPackagePortion(getName());
 649             if (pkg.length() > 0)
 650               resourceName = pkg.replace('.','/') + '/' + resourceName;
 651           }
 652         else
 653           {
 654             resourceName = resourceName.substring(1);
 655           }
 656       }
 657     return resourceName;
 658   }
 659
 660   /**
 661    * Get the signers of this class. This returns null if there are no signers,
 662    * such as for primitive types or void.
 663    *
 664    * @return the signers of this class
 665    * @since 1.1
 666    */
 667   public native Object[] getSigners ();
 668
 669   /**
 670    * Set the signers of this class.
 671    *
 672    * @param signers the signers of this class
 673    */
 674   native void setSigners(Object[] signers);
 675
 676   /**
 677    * Get the direct superclass of this class.  If this is an interface,
 678    * Object, a primitive type, or void, it will return null. If this is an
 679    * array type, it will return Object.
 680    *
 681    * @return the direct superclass of this class
 682    */
 683   public native Class getSuperclass ();
 684
 685   /**
 686    * Return whether this class is an array type.
 687    *
 688    * @return whether this class is an array type
 689    * @since 1.1
 690    */
 691   public native boolean isArray ();
 692
 693   /**
 694    * Discover whether an instance of the Class parameter would be an
 695    * instance of this Class as well.  Think of doing
 696    * <code>isInstance(c.newInstance())</code> or even
 697    * <code>c.newInstance() instanceof (this class)</code>. While this
 698    * checks widening conversions for objects, it must be exact for primitive
 699    * types.
 700    *
 701    * @param c the class to check
 702    * @return whether an instance of c would be an instance of this class
 703    *         as well
 704    * @throws NullPointerException if c is null
 705    * @since 1.1
 706    */
 707   public native boolean isAssignableFrom (Class c);
 708
 709   /**
 710    * Discover whether an Object is an instance of this Class.  Think of it
 711    * as almost like <code>o instanceof (this class)</code>.
 712    *
 713    * @param o the Object to check
 714    * @return whether o is an instance of this class
 715    * @since 1.1
 716    */
 717   public native boolean isInstance (Object o);
 718
 719   /**
 720    * Check whether this class is an interface or not.  Array types are not
 721    * interfaces.
 722    *
 723    * @return whether this class is an interface or not
 724    */
 725   public native boolean isInterface ();
 726
 727   /**
 728    * Return whether this class is a primitive type.  A primitive type class
 729    * is a class representing a kind of "placeholder" for the various
 730    * primitive types, or void.  You can access the various primitive type
 731    * classes through java.lang.Boolean.TYPE, java.lang.Integer.TYPE, etc.,
 732    * or through boolean.class, int.class, etc.
 733    *
 734    * @return whether this class is a primitive type
 735    * @see Boolean#TYPE
 736    * @see Byte#TYPE
 737    * @see Character#TYPE
 738    * @see Short#TYPE
 739    * @see Integer#TYPE
 740    * @see Long#TYPE
 741    * @see Float#TYPE
 742    * @see Double#TYPE
 743    * @see Void#TYPE
 744    * @since 1.1
 745    */
 746   public native boolean isPrimitive ();
 747
 748   /**
 749    * Get a new instance of this class by calling the no-argument constructor.
 750    * The class is initialized if it has not been already. A security check
 751    * may be performed, with <code>checkMemberAccess(this, Member.PUBLIC)</code>
 752    * as well as <code>checkPackageAccess</code> both having to succeed.
 753    *
 754    * @return a new instance of this class
 755    * @throws InstantiationException if there is not a no-arg constructor
 756    *         for this class, including interfaces, abstract classes, arrays,
 757    *         primitive types, and void; or if an exception occurred during
 758    *         the constructor
 759    * @throws IllegalAccessException if you are not allowed to access the
 760    *         no-arg constructor because of scoping reasons
 761    * @throws SecurityException if the security check fails
 762    * @throws ExceptionInInitializerError if class initialization caused by
 763    *         this call fails with an exception
 764    */
 765   public native Object newInstance ()
 766     throws InstantiationException, IllegalAccessException;
 767
 768   // We need a native method to retrieve the protection domain, because we
 769   // can't add fields to java.lang.Class that are accessible from Java.
 770   private native ProtectionDomain getProtectionDomain0();
 771
 772   /**
 773    * Returns the protection domain of this class. If the classloader did not
 774    * record the protection domain when creating this class the unknown
 775    * protection domain is returned which has a <code>null</code> code source
 776    * and all permissions. A security check may be performed, with
 777    * <code>RuntimePermission("getProtectionDomain")</code>.
 778    *
 779    * @return the protection domain
 780    * @throws SecurityException if the security manager exists and the caller
 781    * does not have <code>RuntimePermission("getProtectionDomain")</code>.
 782    * @see RuntimePermission
 783    * @since 1.2
 784    */
 785   public ProtectionDomain getProtectionDomain()
 786   {
 787     SecurityManager sm = System.getSecurityManager();
 788     if (sm != null)
 789       sm.checkPermission(VMClassLoader.protectionDomainPermission);
 790
 791     ProtectionDomain protectionDomain = getProtectionDomain0();
 792
 793     if (protectionDomain == null)
 794       return VMClassLoader.unknownProtectionDomain;
 795     else
 796       return protectionDomain;
 797   }
 798
 799   /**
 800    * Return the human-readable form of this Object.  For an object, this
 801    * is either "interface " or "class " followed by <code>getName()</code>,
 802    * for primitive types and void it is just <code>getName()</code>.
 803    *
 804    * @return the human-readable form of this Object
 805    */
 806   public String toString()
 807   {
 808     if (isPrimitive())
 809       return getName();
 810     return (isInterface() ? "interface " : "class ") + getName();
 811   }
 812
 813   /**
 814    * Returns the desired assertion status of this class, if it were to be
 815    * initialized at this moment. The class assertion status, if set, is
 816    * returned; the backup is the default package status; then if there is
 817    * a class loader, that default is returned; and finally the system default
 818    * is returned. This method seldom needs calling in user code, but exists
 819    * for compilers to implement the assert statement. Note that there is no
 820    * guarantee that the result of this method matches the class's actual
 821    * assertion status.
 822    *
 823    * @return the desired assertion status
 824    * @see ClassLoader#setClassAssertionStatus(String, boolean)
 825    * @see ClassLoader#setPackageAssertionStatus(String, boolean)
 826    * @see ClassLoader#setDefaultAssertionStatus(boolean)
 827    * @since 1.4
 828    */
 829   public boolean desiredAssertionStatus()
 830   {
 831     ClassLoader c = getClassLoader();
 832     Object status;
 833     if (c == null)
 834       return VMClassLoader.defaultAssertionStatus();
 835     if (c.classAssertionStatus != null)
 836       synchronized (c)
 837         {
 838           status = c.classAssertionStatus.get(getName());
 839           if (status != null)
 840             return status.equals(Boolean.TRUE);
 841         }
 842     else
 843       {
 844         status = ClassLoader.systemClassAssertionStatus.get(getName());
 845         if (status != null)
 846           return status.equals(Boolean.TRUE);
 847       }
 848     if (c.packageAssertionStatus != null)
 849       synchronized (c)
 850         {
 851           String name = getPackagePortion(getName());
 852           if ("".equals(name))
 853             status = c.packageAssertionStatus.get(null);
 854           else
 855             do
 856               {
 857                 status = c.packageAssertionStatus.get(name);
 858                 name = getPackagePortion(name);
 859               }
 860             while (! "".equals(name) && status == null);
 861           if (status != null)
 862             return status.equals(Boolean.TRUE);
 863         }
 864     else
 865       {
 866         String name = getPackagePortion(getName());
 867         if ("".equals(name))
 868           status = ClassLoader.systemPackageAssertionStatus.get(null);
 869         else
 870           do
 871             {
 872               status = ClassLoader.systemPackageAssertionStatus.get(name);
 873               name = getPackagePortion(name);
 874             }
 875           while (! "".equals(name) && status == null);
 876         if (status != null)
 877           return status.equals(Boolean.TRUE);
 878       }
 879     return c.defaultAssertionStatus;
 880   }
 881
 882   /**
 883    * Strip the last portion of the name (after the last dot).
 884    *
 885    * @param name the name to get package of
 886    * @return the package name, or "" if no package
 887    */
 888   private static String getPackagePortion(String name)
 889   {
 890     int lastInd = name.lastIndexOf('.');
 891     if (lastInd == -1)
 892       return "";
 893     return name.substring(0, lastInd);
 894   }
 895
 896   /**
 897    * Perform security checks common to all of the methods that
 898    * get members of this Class.
 899    */
 900   private void memberAccessCheck(int which)
 901   {
 902     SecurityManager sm = System.getSecurityManager();
 903     if (sm != null)
 904       {
 905         sm.checkMemberAccess(this, which);
 906         Package pkg = getPackage();
 907         if (pkg != null)
 908           sm.checkPackageAccess(pkg.getName());
 909       }
 910   }
 911 }