libjava/classpath/tools/gnu/classpath/tools/FileSystemClassLoader.java

   1 /* gnu.classpath.tools.FileSystemClassLoader
   2    Copyright (C) 2004 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 USA. */
  20
  21 package gnu.classpath.tools;
  22
  23 import java.io.File;
  24 import java.io.FileInputStream;
  25 import java.io.FileNotFoundException;
  26 import java.io.InputStream;
  27 import java.io.IOException;
  28 import java.io.StreamTokenizer;
  29 import java.io.StringReader;
  30
  31 import java.net.MalformedURLException;
  32 import java.net.URL;
  33
  34 import java.util.LinkedList;
  35 import java.util.List;
  36 import java.util.ArrayList;
  37 import java.util.StringTokenizer;
  38
  39 import java.util.jar.JarEntry;
  40 import java.util.jar.JarFile;
  41 import java.util.jar.Manifest;
  42 import java.util.jar.Attributes;
  43
  44 /**
  45  *  A <code>ClassLoader</code> implementation which looks for classes
  46  *  on the local filesystem given a standard search path.
  47  */
  48 public class FileSystemClassLoader extends ClassLoader {
  49
  50    private File[] pathComponents;
  51
  52    /**
  53     *  Initialize the class loader with a normal path string. The path
  54     *  string should contain path components separated by {@link
  55     *  File.pathSeparator}. Each path component should either denote a
  56     *  directory or a .jar or .zip file.
  57     */
  58    public FileSystemClassLoader(String path)
  59    {
  60       List components = new ArrayList();
  61       for (StringTokenizer st = new StringTokenizer(path, File.pathSeparator); st.hasMoreTokens(); ) {
  62          File pathComponent = new File(st.nextToken());
  63          components.add(pathComponent);
  64          if (pathComponent.exists() && !pathComponent.isDirectory()) {
  65             List subComponents = tryGetJarFileClassPathComponents(pathComponent);
  66             if (null != subComponents) {
  67                components.addAll(subComponents);
  68             }
  69          }
  70       }
  71       File[] componentArray = new File[components.size()];
  72       this.pathComponents = (File[])components.toArray(componentArray);
  73    }
  74
  75    /**
  76     *  Initialize the class loader with an array of path
  77     *  components. Each path component should either denote a
  78     *  directory or a .jar or .zip file.
  79     */
  80    public FileSystemClassLoader(File[] pathComponents)
  81    {
  82       this.pathComponents = pathComponents;
  83       for (int i = 0; i < pathComponents.length; ++i) {
  84          if (!pathComponents[i].exists()) {
  85             System.err.println("WARNING: Path component '" + pathComponents[i] + "' not found.");
  86          }
  87       }
  88    }
  89
  90    public Class loadClass(String name)
  91       throws ClassNotFoundException {
  92
  93       return super.loadClass(name);
  94    }
  95
  96    public Class findClass(String name)
  97       throws ClassNotFoundException {
  98
  99       byte[] b = loadClassData(name);
 100       return defineClass(name, b, 0, b.length);
 101    }
 102
 103    public URL findResource(String name)
 104    {
 105       StreamInfo streamInfo = getResourceStream(name);
 106       if (null == streamInfo) {
 107          return super.findResource(name);
 108       }
 109       else {
 110          try {
 111             return streamInfo.getURL();
 112          }
 113          catch (MalformedURLException e) {
 114             System.err.println("WARNING: In FileSystemClassLoader: could not derive URL from file or jar entry: " + e.toString());
 115             return null;
 116          }
 117       }
 118    }
 119
 120    private byte[] readFromStream(InputStream in, long size)
 121       throws IOException
 122    {
 123       byte[] result = new byte[(int)size];
 124       int nread = 0;
 125       int offset = 0;
 126       while (offset < size && (nread = in.read(result, offset, (int)(size - offset))) >= 0) {
 127          offset += nread;
 128       }
 129       in.close();
 130       return result;
 131    }
 132
 133    private byte[] readFromStream(StreamInfo streamInfo)
 134       throws IOException
 135    {
 136       InputStream in = streamInfo.openStream();
 137       long size = streamInfo.getSize();
 138
 139       byte[] result = new byte[(int)size];
 140       int nread = 0;
 141       int offset = 0;
 142       while (offset < size && (nread = in.read(result, offset, (int)(size - offset))) >= 0) {
 143          offset += nread;
 144       }
 145       in.close();
 146       return result;
 147    }
 148
 149    private static interface StreamInfo
 150    {
 151       public InputStream openStream()
 152          throws IOException;
 153       public long getSize();
 154       public URL getURL()
 155          throws MalformedURLException;
 156    }
 157
 158    private static class FileStreamInfo
 159       implements StreamInfo
 160    {
 161       File file;
 162
 163       FileStreamInfo(File file)
 164       {
 165          this.file = file;
 166       }
 167
 168       public InputStream openStream()
 169          throws IOException
 170       {
 171          return new FileInputStream(file);
 172       }
 173
 174       public long getSize()
 175       {
 176          return file.length();
 177       }
 178
 179       public URL getURL()
 180          throws MalformedURLException
 181       {
 182          return file.toURL();
 183       }
 184    }
 185
 186    private static class JarStreamInfo
 187       implements StreamInfo
 188    {
 189       private File file;
 190       private JarFile jarFile;
 191       private JarEntry jarEntry;
 192
 193       JarStreamInfo(File file, JarFile jarFile, JarEntry jarEntry)
 194       {
 195          this.file = file;
 196          this.jarFile = jarFile;
 197          this.jarEntry = jarEntry;
 198       }
 199
 200       public InputStream openStream()
 201          throws IOException
 202       {
 203          return jarFile.getInputStream(jarEntry);
 204       }
 205
 206       public long getSize()
 207       {
 208          return jarEntry.getSize();
 209       }
 210
 211       public URL getURL()
 212          throws MalformedURLException
 213       {
 214          String urlString = "jar:" + file.toURL() + "!/" + jarEntry.getName();
 215          return new URL(urlString);
 216       }
 217    }
 218
 219    private StreamInfo getResourceStream(String path)
 220    {
 221       for (int i = 0; i < pathComponents.length; ++i) {
 222          try {
 223             File parent = pathComponents[i];
 224             if (parent.isDirectory()) {
 225                File file = new File(parent, path);
 226                if (file.exists()) {
 227                   return new FileStreamInfo(file);
 228                }
 229             }
 230             else {
 231                JarFile jarFile = new JarFile(parent, false, JarFile.OPEN_READ);
 232                JarEntry jarEntry = jarFile.getJarEntry(path);
 233                if (null != jarEntry) {
 234                   return new JarStreamInfo(parent, jarFile, jarEntry);
 235                }
 236             }
 237          }
 238          catch (IOException ignore) {
 239          }
 240       }
 241       return null;
 242    }
 243
 244    private byte[] loadClassData(String className)
 245       throws ClassNotFoundException
 246    {
 247       String classFileName = className.replace('.', File.separatorChar) + ".class";
 248       StreamInfo streamInfo = getResourceStream(classFileName);
 249
 250       try {
 251          if (null != streamInfo) {
 252             return readFromStream(streamInfo);
 253          }
 254       }
 255       catch (IOException ignore) {
 256       }
 257
 258       throw new ClassNotFoundException(className);
 259    }
 260
 261    private static List tryGetJarFileClassPathComponents(File file)
 262    {
 263       try {
 264          JarFile jarFile = new JarFile(file, false, JarFile.OPEN_READ);
 265          Manifest manifest = jarFile.getManifest();
 266          if (null != manifest) {
 267             Attributes mainAttributes = manifest.getMainAttributes();
 268             if (null != mainAttributes) {
 269                String classPath = mainAttributes.getValue(Attributes.Name.CLASS_PATH);
 270                if (null != classPath) {
 271                   List result = new LinkedList();
 272                   StreamTokenizer tokenizer = new StreamTokenizer(new StringReader(classPath));
 273                   tokenizer.resetSyntax();
 274                   tokenizer.wordChars(0, Integer.MAX_VALUE);
 275                   tokenizer.whitespaceChars(9, 9);   // tab
 276                   tokenizer.whitespaceChars(10, 10); // lf
 277                   tokenizer.whitespaceChars(13, 13); // cr
 278                   tokenizer.whitespaceChars(32, 32); // space
 279                   tokenizer.quoteChar('"');
 280                   int token;
 281                   while ((token = tokenizer.nextToken()) != StreamTokenizer.TT_EOF) {
 282                      if (StreamTokenizer.TT_WORD == token) {
 283                         result.add(new File(file.getParentFile(), tokenizer.sval));
 284                      }
 285                   }
 286                   return result;
 287                }
 288             }
 289          }
 290       }
 291       catch (IOException ignore) {
 292       }
 293       return null;
 294    }
 295 }
 296