FreeChainXenon/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Imported GNU Classpath 0.92

Browse source 
2006-08-14  Mark Wielaard  <mark@klomp.org>

       Imported GNU Classpath 0.92
       * HACKING: Add more importing hints. Update automake version
       requirement.

       * configure.ac (gconf-peer): New enable AC argument.
       Add --disable-gconf-peer and --enable-default-preferences-peer
       to classpath configure when gconf is disabled.
       * scripts/makemake.tcl: Set gnu/java/util/prefs/gconf and
       gnu/java/awt/dnd/peer/gtk to bc. Classify
       gnu/java/security/Configuration.java as generated source file.

       * gnu/java/lang/management/VMGarbageCollectorMXBeanImpl.java,
       gnu/java/lang/management/VMMemoryPoolMXBeanImpl.java,
       gnu/java/lang/management/VMClassLoadingMXBeanImpl.java,
       gnu/java/lang/management/VMRuntimeMXBeanImpl.java,
       gnu/java/lang/management/VMMemoryManagerMXBeanImpl.java,
       gnu/java/lang/management/VMThreadMXBeanImpl.java,
       gnu/java/lang/management/VMMemoryMXBeanImpl.java,
       gnu/java/lang/management/VMCompilationMXBeanImpl.java: New VM stub
       classes.
       * java/lang/management/VMManagementFactory.java: Likewise.
       * java/net/VMURLConnection.java: Likewise.
       * gnu/java/nio/VMChannel.java: Likewise.

       * java/lang/Thread.java (getState): Add stub implementation.
       * java/lang/Class.java (isEnum): Likewise.
       * java/lang/Class.h (isEnum): Likewise.

       * gnu/awt/xlib/XToolkit.java (getClasspathTextLayoutPeer): Removed.

       * javax/naming/spi/NamingManager.java: New override for StackWalker
       functionality.

       * configure, sources.am, Makefile.in, gcj/Makefile.in,
       include/Makefile.in, testsuite/Makefile.in: Regenerated.

From-SVN: r116139
This commit is contained in:
Mark Wielaard 2006-08-14 23:12:35 +00:00
parent abab460491
commit ac1ed908de
1294 changed files with 99479 additions and 35933 deletions
Download patch file Download diff file Expand all files Collapse all files

215
libjava/classpath/gnu/java/net/loader/JarURLLoader.java Normal file
View file

@ -0,0 +1,215 @@
package gnu.java.net.loader;
import gnu.java.net.IndexListParser;
import java.io.IOException;
import java.net.JarURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.net.URLStreamHandlerFactory;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.jar.Attributes;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import java.util.jar.Manifest;
/**
* A <code>JarURLLoader</code> is a type of <code>URLLoader</code>
* only loading from jar url.
*/
public final class JarURLLoader extends URLLoader
{
// True if we've initialized -- i.e., tried open the jar file.
boolean initialized;
// The jar file for this url.
JarFile jarfile;
// Base jar: url for all resources loaded from jar.
final URL baseJarURL;
// The "Class-Path" attribute of this Jar's manifest.
ArrayList classPath;
// If not null, a mapping from INDEX.LIST for this jar only.
// This is a set of all prefixes and top-level files that
// ought to be available in this jar.
Set indexSet;
// This constructor is used internally. It purposely does not open
// the jar file -- it defers this until later. This allows us to
// implement INDEX.LIST lazy-loading semantics.
private JarURLLoader(URLClassLoader classloader, URLStreamHandlerCache cache,
URLStreamHandlerFactory factory,
URL baseURL, URL absoluteUrl,
Set indexSet)
{
super(classloader, cache, factory, baseURL, absoluteUrl);
URL newBaseURL = null;
try
{
// Cache url prefix for all resources in this jar url.
String base = baseURL.toExternalForm() + "!/";
newBaseURL = new URL("jar", "", -1, base, cache.get(factory, "jar"));
}
catch (MalformedURLException ignore)
{
// Ignore.
}
this.baseJarURL = newBaseURL;
this.classPath = null;
this.indexSet = indexSet;
}
// This constructor is used by URLClassLoader. It will immediately
// try to read the jar file, in case we've found an index or a class-path
// setting. FIXME: it would be nice to defer this as well, but URLClassLoader
// makes this hard.
public JarURLLoader(URLClassLoader classloader, URLStreamHandlerCache cache,
URLStreamHandlerFactory factory,
URL baseURL, URL absoluteUrl)
{
this(classloader, cache, factory, baseURL, absoluteUrl, null);
initialize();
}
private void initialize()
{
JarFile jarfile = null;
try
{
jarfile =
((JarURLConnection) baseJarURL.openConnection()).getJarFile();
Manifest manifest;
Attributes attributes;
String classPathString;
IndexListParser parser = new IndexListParser(jarfile, baseJarURL,
baseURL);
LinkedHashMap indexMap = parser.getHeaders();
if (indexMap != null)
{
// Note that the index also computes
// the resulting Class-Path -- there are jars out there
// where the index lists some required jars which do
// not appear in the Class-Path attribute in the manifest.
this.classPath = new ArrayList();
Iterator it = indexMap.entrySet().iterator();
while (it.hasNext())
{
Map.Entry entry = (Map.Entry) it.next();
URL subURL = (URL) entry.getKey();
Set prefixes = (Set) entry.getValue();
if (subURL.equals(baseURL))
this.indexSet = prefixes;
else
{
JarURLLoader subLoader = new JarURLLoader(classloader,
cache,
factory, subURL,
subURL,
prefixes);
// Note that we don't care if the sub-loader itself has an
// index or a class-path -- only the top-level jar
// file gets this treatment; its index should cover
// everything.
this.classPath.add(subLoader);
}
}
}
else if ((manifest = jarfile.getManifest()) != null
&& (attributes = manifest.getMainAttributes()) != null
&& ((classPathString
= attributes.getValue(Attributes.Name.CLASS_PATH))
!= null))
{
this.classPath = new ArrayList();
StringTokenizer st = new StringTokenizer(classPathString, " ");
while (st.hasMoreElements ())
{
String e = st.nextToken ();
try
{
URL subURL = new URL(baseURL, e);
// We've seen at least one jar file whose Class-Path
// attribute includes the original jar. If we process
// that normally we end up with infinite recursion.
if (subURL.equals(baseURL))
continue;
JarURLLoader subLoader = new JarURLLoader(classloader,
cache, factory,
subURL, subURL);
this.classPath.add(subLoader);
ArrayList extra = subLoader.getClassPath();
if (extra != null)
this.classPath.addAll(extra);
}
catch (java.net.MalformedURLException xx)
{
// Give up
}
}
}
}
catch (IOException ioe)
{
/* ignored */
}
this.jarfile = jarfile;
this.initialized = true;
}
/** get resource with the name "name" in the jar url */
public Resource getResource(String name)
{
if (name.startsWith("/"))
name = name.substring(1);
if (indexSet != null)
{
// Trust the index.
String basename = name;
int offset = basename.lastIndexOf('/');
if (offset != -1)
basename = basename.substring(0, offset);
if (! indexSet.contains(basename))
return null;
// FIXME: if the index claim to hold the resource, and jar file
// doesn't have it, we're supposed to throw an exception. However,
// in our model this is tricky to implement, as another URLLoader from
// the same top-level jar may have an overlapping index entry.
}
if (! initialized)
initialize();
if (jarfile == null)
return null;
JarEntry je = jarfile.getJarEntry(name);
if (je != null)
return new JarURLResource(this, name, je);
else
return null;
}
public Manifest getManifest()
{
try
{
return (jarfile == null) ? null : jarfile.getManifest();
}
catch (IOException ioe)
{
return null;
}
}
public ArrayList getClassPath()
{
return classPath;
}
}