yggdrasil/gcc
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Imported GNU Classpath 0.19 + gcj-import-20051115.

Browse Source 
* sources.am: Regenerated.
       * Makefile.in: Likewise.
       * scripts/makemake.tcl: Use glob -nocomplain.

From-SVN: r107049
This commit is contained in:
Mark Wielaard
2005-11-15 23:20:01 +00:00
parent 02e549bfaa
commit 8f523f3a10
1241 changed files with 97711 additions and 25284 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libjava/classpath/java/rmi/server/LoaderHandler.java
+5 -1
View File
@@ -45,7 +45,11 @@ import java.net.URL;
*/
public interface LoaderHandler
{
String packagePrefix = "";
/**
* For binary compatibility with the JDK, the string "sun.rmi.server".
* Not actually used for anything.
*/
String packagePrefix = "sun.rmi.server";
/**
* @deprecated
libjava/classpath/java/rmi/server/RMIClassLoader.java
+75 -237
View File
@@ -38,14 +38,10 @@ exception statement from your version. */
package java.rmi.server;
import gnu.java.rmi.server.RMIClassLoaderImpl;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.Map;
import java.util.StringTokenizer;
/**
* This class provides a set of public static utility methods for supporting
@@ -60,221 +56,77 @@ public class RMIClassLoader
*/
private RMIClassLoader() {}
private static class MyClassLoader extends URLClassLoader
{
// Package-private to avoid a trampoline constructor.
MyClassLoader (URL[] urls, ClassLoader parent, String annotation)
{
super (urls, parent);
this.annotation = annotation;
}
private MyClassLoader (URL[] urls, ClassLoader parent)
{
super (urls, parent);
this.annotation = urlToAnnotation (urls);
}
public static String urlToAnnotation (URL[] urls)
{
if (urls.length == 0)
return null;
StringBuffer annotation = new StringBuffer (64 * urls.length);
for (int i = 0; i < urls.length; i++)
{
annotation.append (urls [i].toExternalForm());
annotation.append (' ');
}
return annotation.toString();
}
public final String getClassAnnotation()
{
return annotation;
}
private final String annotation;
}
/**
* This class is used to identify a cached classloader by its codebase and
* the context classloader that is its parent.
*/
private static class CacheKey
{
private String mCodeBase;
private ClassLoader mContextClassLoader;
public CacheKey (String theCodebase, ClassLoader theContextClassLoader)
{
mCodeBase = theCodebase;
mContextClassLoader = theContextClassLoader;
}
/**
* @return true if the codebase and the context classloader are equal
*/
public boolean equals (Object theOther)
{
if (theOther instanceof CacheKey)
{
CacheKey key = (CacheKey) theOther;
return (equals (this.mCodeBase,key.mCodeBase)
&& equals (this.mContextClassLoader, key.mContextClassLoader));
}
return false;
}
/**
* Test if the two objects are equal or both null.
* @param theOne
* @param theOther
* @return
*/
private boolean equals (Object theOne, Object theOther)
{
return theOne != null ? theOne.equals (theOther) : theOther == null;
}
/**
* @return hashCode
*/
public int hashCode()
{
return ((mCodeBase != null ? mCodeBase.hashCode() : 0)
^(mContextClassLoader != null ? mContextClassLoader.hashCode() : -1));
}
public String toString()
{
return "[" + mCodeBase + "," + mContextClassLoader + "]";
}
}
private static Map cacheLoaders; //map annotations to loaders
private static Map cacheAnnotations; //map loaders to annotations
//defaultAnnotation is got from system property
// "java.rmi.server.defaultAnnotation"
private static String defaultAnnotation;
//URL object for defaultAnnotation
private static URL defaultCodebase;
//class loader for defaultAnnotation
private static MyClassLoader defaultLoader;
static
{
// 89 is a nice prime number for Hashtable initial capacity
cacheLoaders = new Hashtable (89);
cacheAnnotations = new Hashtable (89);
defaultAnnotation = System.getProperty ("java.rmi.server.defaultAnnotation");
try
{
if (defaultAnnotation != null)
defaultCodebase = new URL (defaultAnnotation);
}
catch (Exception _)
{
defaultCodebase = null;
}
if (defaultCodebase != null)
{
defaultLoader = new MyClassLoader (new URL[] { defaultCodebase }, null,
defaultAnnotation);
cacheLoaders.put (new CacheKey (defaultAnnotation,
Thread.currentThread().getContextClassLoader()),
defaultLoader);
}
}
/**
* @deprecated
*/
public static Class loadClass (String name)
public static Class loadClass(String name)
throws MalformedURLException, ClassNotFoundException
{
return loadClass ("", name);
return loadClass("", name);
}
public static Class loadClass (String codebases, String name)
public static Class loadClass(String codebase, String name)
throws MalformedURLException, ClassNotFoundException
{
ClassLoader loader = Thread.currentThread().getContextClassLoader();
RMIClassLoaderSpi spi = getProviderInstance();
if (spi == null)
spi = getDefaultProviderInstance();
return spi.loadClass(codebase, name, null);
}
//try context class loader first
try
{
return Class.forName(name, false, loader);
}
catch (ClassNotFoundException e)
{
// class not found in the local classpath
}
public static Class loadClass(String codebase, String name,
ClassLoader defaultLoader)
throws MalformedURLException, ClassNotFoundException
{
RMIClassLoaderSpi spi = getProviderInstance();
if (spi == null)
spi = getDefaultProviderInstance();
return spi.loadClass(codebase, name, defaultLoader);
}
if (codebases.length() == 0) //==""
{
loader = defaultLoader;
}
else
{
loader = getClassLoader(codebases);
}
if (loader == null)
{
//do not throw NullPointerException
throw new ClassNotFoundException ("Could not find class (" + name +
") at codebase (" + codebases + ")");
}
return Class.forName(name, false, loader);
/**
* Loads a class from <code>codeBase</code>.
*
* This method delegates to
* {@link RMIClassLoaderSpi#loadClass(String, String, ClassLoader)} and
* passes <code>codeBase.toString()</code> as first argument,
* <code>name</code> as second argument and <code>null</code> as third
* argument.
*
* @param codeBase the code base from which to load the class
* @param name the name of the class
*
* @return the loaded class
*
* @throws MalformedURLException if the URL is not well formed
* @throws ClassNotFoundException if the requested class cannot be found
*/
public static Class loadClass(URL codeBase, String name)
throws MalformedURLException, ClassNotFoundException
{
RMIClassLoaderSpi spi = getProviderInstance();
if (spi == null)
spi = getDefaultProviderInstance();
return spi.loadClass(codeBase.toString(), name, null);
}
/**
* Gets a classloader for the given codebase and with the current
* context classloader as parent.
*
* @param codebases
* @param codebase
*
* @return a classloader for the given codebase
*
* @throws MalformedURLException if the codebase contains a malformed URL
*/
public static ClassLoader getClassLoader (String codebases)
public static ClassLoader getClassLoader(String codebase)
throws MalformedURLException
{
ClassLoader loader;
CacheKey loaderKey = new CacheKey
(codebases, Thread.currentThread().getContextClassLoader());
loader = (ClassLoader) cacheLoaders.get (loaderKey);
if (loader == null)
{
//create an entry in cacheLoaders mapping a loader to codebases.
// codebases are separated by " "
StringTokenizer tok = new StringTokenizer (codebases, " ");
ArrayList urls = new ArrayList();
while (tok.hasMoreTokens())
urls.add (new URL (tok.nextToken()));
loader = new MyClassLoader ((URL[]) urls.toArray (new URL [urls.size()]),
Thread.currentThread().getContextClassLoader(),
codebases);
cacheLoaders.put (loaderKey, loader);
}
return loader;
RMIClassLoaderSpi spi = getProviderInstance();
if (spi == null)
spi = getDefaultProviderInstance();
return spi.getClassLoader(codebase);
}
/**
@@ -286,47 +138,12 @@ public class RMIClassLoader
* @return a space seperated list of URLs where the class-definition
* of cl may be found
*/
public static String getClassAnnotation (Class cl)
public static String getClassAnnotation(Class cl)
{
ClassLoader loader = cl.getClassLoader();
if (loader == null
|| loader == ClassLoader.getSystemClassLoader())
{
return System.getProperty ("java.rmi.server.codebase");
}
if (loader instanceof MyClassLoader)
{
return ((MyClassLoader) loader).getClassAnnotation();
}
String s = (String) cacheAnnotations.get (loader);
if (s != null)
return s;
if (loader instanceof URLClassLoader)
{
URL[] urls = ((URLClassLoader) loader).getURLs();
if (urls.length == 0)
return null;
StringBuffer annotation = new StringBuffer (64 * urls.length);
for (int i = 0; i < urls.length; i++)
{
annotation.append (urls [i].toExternalForm());
annotation.append (' ');
}
s = annotation.toString();
cacheAnnotations.put (loader, s);
return s;
}
return System.getProperty ("java.rmi.server.codebase");
RMIClassLoaderSpi spi = getProviderInstance();
if (spi == null)
spi = getDefaultProviderInstance();
return spi.getClassAnnotation(cl);
}
/**
@@ -336,4 +153,25 @@ public class RMIClassLoader
{
throw new Error ("Not implemented");
}
/**
* Returns the default service provider for <code>RMIClassLoader</code>.
*
* @return the default provider for <code>RMIClassLoader</code>
*/
public static RMIClassLoaderSpi getDefaultProviderInstance()
{
return RMIClassLoaderImpl.getInstance();
}
/**
* Chooses, instantiates and returns a service provider.
*
* @return a service provider
*/
private static RMIClassLoaderSpi getProviderInstance()
{
// TODO: Do something more useful here.
return null;
}
}
libjava/classpath/java/rmi/server/RemoteObject.java
+3 -1
View File
@@ -120,7 +120,9 @@ public boolean equals(Object obj) {
in.read (); //some unknown UnicastRef2 field
}
cname = RemoteRef.packagePrefix + '.' + cname;
// It would be nice to use RemoteRef.packagePrefix here, but for binary
// compatibility with the JDK that has to contain "sun.rmi.server"...
cname = "gnu.java.rmi.server." + cname;
try
{
Class cls = Class.forName(cname);
libjava/classpath/java/rmi/server/RemoteRef.java
+5 -1
View File
@@ -48,7 +48,11 @@ public interface RemoteRef extends Externalizable
{
long serialVersionUID = 3632638527362204081L;
String packagePrefix = "gnu.java.rmi.server";
/**
* For binary compatibility with the JDK, the string "sun.rmi.server".
* Not actually used for anything.
*/
String packagePrefix = "sun.rmi.server";
/**
* @deprecated