/* gnu.classpath.tools.FileSystemClassLoader
Copyright (C) 2004 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */
package gnu.classpath.tools;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.io.IOException;
import java.io.StreamTokenizer;
import java.io.StringReader;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.LinkedList;
import java.util.List;
import java.util.ArrayList;
import java.util.StringTokenizer;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import java.util.jar.Manifest;
import java.util.jar.Attributes;
/**
* A <code>ClassLoader</code> implementation which looks for classes
* on the local filesystem given a standard search path.
*/
public class FileSystemClassLoader extends ClassLoader {
private File[] pathComponents;
/**
* Initialize the class loader with a normal path string. The path
* string should contain path components separated by {@link
* File.pathSeparator}. Each path component should either denote a
* directory or a .jar or .zip file.
*/
public FileSystemClassLoader(String path)
{
List components = new ArrayList();
for (StringTokenizer st = new StringTokenizer(path, File.pathSeparator); st.hasMoreTokens(); ) {
File pathComponent = new File(st.nextToken());
components.add(pathComponent);
if (pathComponent.exists() && !pathComponent.isDirectory()) {
List subComponents = tryGetJarFileClassPathComponents(pathComponent);
if (null != subComponents) {
components.addAll(subComponents);
}
}
}
File[] componentArray = new File[components.size()];
this.pathComponents = (File[])components.toArray(componentArray);
}
/**
* Initialize the class loader with an array of path
* components. Each path component should either denote a
* directory or a .jar or .zip file.
*/
public FileSystemClassLoader(File[] pathComponents)
{
this.pathComponents = pathComponents;
for (int i = 0; i < pathComponents.length; ++i) {
if (!pathComponents[i].exists()) {
System.err.println("WARNING: Path component '" + pathComponents[i] + "' not found.");
}
}
}
public Class loadClass(String name)
throws ClassNotFoundException {
return super.loadClass(name);
}
public Class findClass(String name)
throws ClassNotFoundException {
byte[] b = loadClassData(name);
return defineClass(name, b, 0, b.length);
}
public URL findResource(String name)
{
StreamInfo streamInfo = getResourceStream(name);
if (null == streamInfo) {
return super.findResource(name);
}
else {
try {
return streamInfo.getURL();
}
catch (MalformedURLException e) {
System.err.println("WARNING: In FileSystemClassLoader: could not derive URL from file or jar entry: " + e.toString());
return null;
}
}
}
private byte[] readFromStream(InputStream in, long size)
throws IOException
{
byte[] result = new byte[(int)size];
int nread = 0;
int offset = 0;
while (offset < size && (nread = in.read(result, offset, (int)(size - offset))) >= 0) {
offset += nread;
}
in.close();
return result;
}
private byte[] readFromStream(StreamInfo streamInfo)
throws IOException
{
InputStream in = streamInfo.openStream();
long size = streamInfo.getSize();
byte[] result = new byte[(int)size];
int nread = 0;
int offset = 0;
while (offset < size && (nread = in.read(result, offset, (int)(size - offset))) >= 0) {
offset += nread;
}
in.close();
return result;
}
private static interface StreamInfo
{
public InputStream openStream()
throws IOException;
public long getSize();
public URL getURL()
throws MalformedURLException;
}
private static class FileStreamInfo
implements StreamInfo
{
File file;
FileStreamInfo(File file)
{
this.file = file;
}
public InputStream openStream()
throws IOException
{
return new FileInputStream(file);
}
public long getSize()
{
return file.length();
}
public URL getURL()
throws MalformedURLException
{
return file.toURL();
}
}
private static class JarStreamInfo
implements StreamInfo
{
private File file;
private JarFile jarFile;
private JarEntry jarEntry;
JarStreamInfo(File file, JarFile jarFile, JarEntry jarEntry)
{
this.file = file;
this.jarFile = jarFile;
this.jarEntry = jarEntry;
}
public InputStream openStream()
throws IOException
{
return jarFile.getInputStream(jarEntry);
}
public long getSize()
{
return jarEntry.getSize();
}
public URL getURL()
throws MalformedURLException
{
String urlString = "jar:" + file.toURL() + "!/" + jarEntry.getName();
return new URL(urlString);
}
}
private StreamInfo getResourceStream(String path)
{
for (int i = 0; i < pathComponents.length; ++i) {
try {
File parent = pathComponents[i];
if (parent.isDirectory()) {
File file = new File(parent, path);
if (file.exists()) {
return new FileStreamInfo(file);
}
}
else {
JarFile jarFile = new JarFile(parent, false, JarFile.OPEN_READ);
JarEntry jarEntry = jarFile.getJarEntry(path);
if (null != jarEntry) {
return new JarStreamInfo(parent, jarFile, jarEntry);
}
}
}
catch (IOException ignore) {
}
}
return null;
}
private byte[] loadClassData(String className)
throws ClassNotFoundException
{
String classFileName = className.replace('.', File.separatorChar) + ".class";
StreamInfo streamInfo = getResourceStream(classFileName);
try {
if (null != streamInfo) {
return readFromStream(streamInfo);
}
}
catch (IOException ignore) {
}
throw new ClassNotFoundException(className);
}
private static List tryGetJarFileClassPathComponents(File file)
{
try {
JarFile jarFile = new JarFile(file, false, JarFile.OPEN_READ);
Manifest manifest = jarFile.getManifest();
if (null != manifest) {
Attributes mainAttributes = manifest.getMainAttributes();
if (null != mainAttributes) {
String classPath = mainAttributes.getValue(Attributes.Name.CLASS_PATH);
if (null != classPath) {
List result = new LinkedList();
StreamTokenizer tokenizer = new StreamTokenizer(new StringReader(classPath));
tokenizer.resetSyntax();
tokenizer.wordChars(0, Integer.MAX_VALUE);
tokenizer.whitespaceChars(9, 9); // tab
tokenizer.whitespaceChars(10, 10); // lf
tokenizer.whitespaceChars(13, 13); // cr
tokenizer.whitespaceChars(32, 32); // space
tokenizer.quoteChar('"');
int token;
while ((token = tokenizer.nextToken()) != StreamTokenizer.TT_EOF) {
if (StreamTokenizer.TT_WORD == token) {
result.add(new File(file.getParentFile(), tokenizer.sval));
}
}
return result;
}
}
}
}
catch (IOException ignore) {
}
return null;
}
}