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.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@116139 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 215 insertions, 0 deletions

diff --git a/libjava/classpath/gnu/java/net/loader/JarURLLoader.java b/libjava/classpath/gnu/java/net/loader/JarURLLoader.java
new file mode 100644
index 00000000000..9385760d547
--- /dev/null
+++ b/libjava/classpath/gnu/java/net/loader/JarURLLoader.java
@@ -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;
+  }
+}