/**
   * Chain together a ClassReader than will read the given class and a ClassWriter to write out a
   * new class with an adapter in the middle to add annotations
   *
   * @param fromName the name of the class we're coming from
   */
  private static void adaptClass(String fromName) {
    if (VERBOSE) System.out.println("Adding annotations to class: " + fromName);

    // gets an input stream to read the bytecode of the class
    String resource = fromName.replace('.', '/') + ".class";
    InputStream is = BootstrapClassLoader.getBootstrapClassLoader().getResourceAsStream(resource);
    byte[] b;

    // adapts the class on the fly
    try {
      ClassReader cr = new ClassReader(is);
      ClassWriter cw = new ClassWriter(0);
      ClassVisitor cv = new AddAnnotationClassAdapter(cw, fromName);
      cr.accept(cv, 0);
      b = cw.toByteArray();
    } catch (Exception e) {
      throw new Error("Couldn't find class " + fromName + " (" + resource + ")", e);
    }

    // store the adapted class on disk
    try {
      File file = new File(destinationDir + resource);
      new File(file.getParent()).mkdirs(); // ensure we have a directory to write to
      FileOutputStream fos = new FileOutputStream(file);
      fos.write(b);
      fos.close();
    } catch (Exception e) {
      throw new Error("Error writing to " + destinationDir + resource + " to disk", e);
    }
  }
Exemplo n.º 2
0
 public ClassLoader getClassLoader() {
   SecurityManager security = System.getSecurityManager();
   if (security != null) {
     ClassLoader parentCL = RVMClass.getClassLoaderFromStackFrame(1);
     if (parentCL != null) {
       security.checkPermission(new RuntimePermission("getClassLoader"));
     }
   }
   ClassLoader cl = type.getClassLoader();
   return cl == BootstrapClassLoader.getBootstrapClassLoader() ? null : cl;
 }
Exemplo n.º 3
0
 /**
  * This method must be provided by the vm vendor, as it is used by other provided class
  * implementations. For example, java.io.ObjectInputStream.readObject() and
  * java.io.ObjectInputStream.resolveProxyClass(). It is also useful for other classes, such as
  * java.rmi.server.RMIClassLoader. Walk the stack and answer the most recent non-null and
  * non-bootstrap ClassLoader on the stack of the calling thread. If no such ClassLoader is found,
  * null is returned. Notes: 1) This method operates on the defining classes of methods on stack.
  * NOT the classes of receivers.
  *
  * @return the first non-bootstrap ClassLoader on the stack
  */
 public static final ClassLoader getNonBootstrapClassLoader() {
   StackBrowser browser = new StackBrowser();
   browser.init();
   while (browser.hasMoreFrames()) {
     ClassLoader cl = browser.getClassLoader();
     if (cl != BootstrapClassLoader.getBootstrapClassLoader() && cl != null) {
       return cl;
     }
     browser.up();
   }
   return null;
 }
Exemplo n.º 4
0
 /**
  * This method must be provided by the vm vendor, as it is used by
  * org.apache.harmony.kernel.vm.MsgHelp.setLocale() to get the bootstrap ClassLoader. MsgHelp uses
  * the bootstrap ClassLoader to find the resource bundle of messages packaged with the bootstrap
  * classes. Returns the ClassLoader of the method (including natives) at the specified depth on
  * the stack of the calling thread. Frames representing the VM implementation of java.lang.reflect
  * are not included in the list. This is not a public method as it can return the bootstrap class
  * loader, which should not be accessed by non-bootstrap classes. Notes:
  *
  * <ul>
  *   <li>This method operates on the defining classes of methods on stack. NOT the classes of
  *       receivers.
  *   <li>The item at depth zero is the caller of this method
  * </ul>
  *
  * @param depth the stack depth of the requested ClassLoader
  * @return the ClassLoader at the specified depth
  * @see java.lang.ClassLoader#getStackClassLoader
  */
 static final ClassLoader getStackClassLoader(int depth) {
   if (org.jikesrvm.VM.runningVM) {
     ClassLoader ans = RVMClass.getClassLoaderFromStackFrame(depth);
     if (ans == BootstrapClassLoader.getBootstrapClassLoader()) {
       return null;
     } else {
       return ans;
     }
   } else {
     return null;
   }
 };
Exemplo n.º 5
0
 /**
  * This method must be included, as it is used by ResourceBundle.getBundle(), and other places as
  * well. The reference implementation of this method uses the getStackClassLoader() method.
  * Returns the ClassLoader of the method that called the caller. i.e. A.x() calls B.y() calls
  * callerClassLoader(), A's ClassLoader will be returned. Returns null for the bootstrap
  * ClassLoader.
  *
  * @return a ClassLoader or null for the bootstrap ClassLoader
  * @throws SecurityException when called from a non-bootstrap Class
  */
 public static ClassLoader callerClassLoader() {
   if (org.jikesrvm.VM.runningVM) {
     ClassLoader ans = RVMClass.getClassLoaderFromStackFrame(2);
     if (ans == BootstrapClassLoader.getBootstrapClassLoader()) {
       return null;
     } else {
       return ans;
     }
   } else {
     return null;
   }
 }
Exemplo n.º 6
0
 public static Class<?> forName(String className, boolean initialize, ClassLoader classLoader)
     throws ClassNotFoundException, LinkageError, ExceptionInInitializerError {
   if (classLoader == null) {
     SecurityManager security = System.getSecurityManager();
     if (security != null) {
       ClassLoader parentCL = RVMClass.getClassLoaderFromStackFrame(1);
       if (parentCL != null) {
         try {
           security.checkPermission(new RuntimePermission("getClassLoader"));
         } catch (SecurityException e) {
           throw new ClassNotFoundException(
               "Security exception when"
                   + " trying to get a classloader so we can load the"
                   + " class named \""
                   + className
                   + "\"",
               e);
         }
       }
     }
     classLoader = BootstrapClassLoader.getBootstrapClassLoader();
   }
   return forNameInternal(className, initialize, classLoader);
 }
Exemplo n.º 7
0
 /**
  * This method must be provided by the vm vendor, as it is used by
  * org.apache.harmony.luni.util.MsgHelp.setLocale() to get the bootstrap ClassLoader. MsgHelp uses
  * the bootstrap ClassLoader to find the resource bundle of messages packaged with the bootstrap
  * classes. The reference implementation of this method uses the getStackClassLoader() method.
  *
  * <p>Returns the ClassLoader of the method that called the caller. i.e. A.x() calls B.y() calls
  * callerClassLoader(), A's ClassLoader will be returned. Returns null for the bootstrap
  * ClassLoader.
  *
  * @return a ClassLoader
  * @throws SecurityException when called from a non-bootstrap Class
  */
 public static ClassLoader bootCallerClassLoader() {
   return BootstrapClassLoader.getBootstrapClassLoader();
 }
Exemplo n.º 8
0
 public InputStream getResourceAsStream(String resName) {
   ClassLoader loader = type.getClassLoader();
   if (loader == BootstrapClassLoader.getBootstrapClassLoader())
     return ClassLoader.getSystemResourceAsStream(toResourceName(resName));
   else return loader.getResourceAsStream(toResourceName(resName));
 }