/*
* This file is part of JOP, the Java Optimized Processor
* see <http://www.jopdesign.com/>
*
* Copyright (C) 2010, Stefan Hepp (stefan@stefant.org).
*
* This program 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 3 of the License, or
* (at your option) any later version.
*
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.apache.bcel.util;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.InputStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.StringTokenizer;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
/**
* Responsible for loading (class) files from the CLASSPATH. Inspired by
* sun.tools.ClassPath.
*
* <p>
* Modifications to the original BCEL class:
* <ul><li>MS FIXED: don't lookup first in current JVM class loader.</li>
*
* </ul>
* </p>
*
* @version $Id: ClassPath.java 386056 2006-03-15 11:31:56Z tcurdt $
* @author <A HREF="mailto:m.dahm@gmx.de">M. Dahm</A>
*/
@SuppressWarnings({"ALL"})
public class ClassPath implements Serializable {
public static final ClassPath SYSTEM_CLASS_PATH = new ClassPath();
private PathEntry[] paths;
private String class_path;
/**
* Search for classes in given path.
*/
public ClassPath(String class_path) {
this.class_path = class_path;
List vec = new ArrayList();
for (StringTokenizer tok = new StringTokenizer(class_path, System
.getProperty("path.separator")); tok.hasMoreTokens();) {
String path = tok.nextToken();
if (!path.equals("")) {
File file = new File(path);
try {
if (file.exists()) {
if (file.isDirectory()) {
vec.add(new Dir(path));
} else {
vec.add(new Zip(new ZipFile(file)));
}
}
} catch (IOException e) {
System.err.println("CLASSPATH component " + file + ": " + e);
}
}
}
paths = new PathEntry[vec.size()];
vec.toArray(paths);
}
/**
* Search for classes in CLASSPATH.
* @deprecated Use SYSTEM_CLASS_PATH constant
*/
public ClassPath() {
this(getClassPath());
}
/** @return used class path string
*/
public String toString() {
return class_path;
}
public int hashCode() {
return class_path.hashCode();
}
public boolean equals( Object o ) {
if (o instanceof ClassPath) {
return class_path.equals(((ClassPath) o).class_path);
}
return false;
}
private static final void getPathComponents( String path, List list ) {
if (path != null) {
StringTokenizer tok = new StringTokenizer(path, File.pathSeparator);
while (tok.hasMoreTokens()) {
String name = tok.nextToken();
File file = new File(name);
if (file.exists()) {
list.add(name);
}
}
}
}
/** Checks for class path components in the following properties:
* "java.class.path", "sun.boot.class.path", "java.ext.dirs"
*
* @return class path as used by default by BCEL
*/
public static final String getClassPath() {
String class_path = System.getProperty("java.class.path");
String boot_path = System.getProperty("sun.boot.class.path");
String ext_path = System.getProperty("java.ext.dirs");
List list = new ArrayList();
getPathComponents(class_path, list);
getPathComponents(boot_path, list);
List dirs = new ArrayList();
getPathComponents(ext_path, dirs);
for (Iterator e = dirs.iterator(); e.hasNext();) {
File ext_dir = new File((String) e.next());
String[] extensions = ext_dir.list(new FilenameFilter() {
public boolean accept( File dir, String name ) {
name = name.toLowerCase(Locale.ENGLISH);
return name.endsWith(".zip") || name.endsWith(".jar");
}
});
if (extensions != null) {
for (int i = 0; i < extensions.length; i++) {
list.add(ext_dir.getPath() + File.separatorChar + extensions[i]);
}
}
}
StringBuffer buf = new StringBuffer();
for (Iterator e = list.iterator(); e.hasNext();) {
buf.append((String) e.next());
if (e.hasNext()) {
buf.append(File.pathSeparatorChar);
}
}
return buf.toString().intern();
}
/**
* @param name fully qualified class name, e.g. java.lang.String
* @return input stream for class
*/
public InputStream getInputStream( String name ) throws IOException {
return getInputStream(name.replace('.', '/'), ".class");
}
/**
* Return stream for class or resource on CLASSPATH.
*
* MS FIXED: don't lookup first in current JVM class loader.
*
* @param name fully qualified file name, e.g. java/lang/String
* @param suffix file name ends with suff, e.g. .java
* @return input stream for file on class path
*/
public InputStream getInputStream( String name, String suffix ) throws IOException {
// InputStream is = null;
// try {
// is = getClass().getClassLoader().getResourceAsStream(name + suffix);
// } catch (Exception e) {
// }
// if (is != null) {
// return is;
// }
return getClassFile(name, suffix).getInputStream();
}
/**
* @param name fully qualified file name, e.g. java/lang/String
* @param suffix file name ends with suff, e.g. .java
* @return class file for the java class
*/
public ClassFile getClassFile( String name, String suffix ) throws IOException {
for (int i = 0; i < paths.length; i++) {
ClassFile cf;
if ((cf = paths[i].getClassFile(name, suffix)) != null) {
return cf;
}
}
throw new IOException("Couldn't find: " + name + suffix);
}
/**
* @param name fully qualified class name, e.g. java.lang.String
* @return input stream for class
*/
public ClassFile getClassFile( String name ) throws IOException {
return getClassFile(name, ".class");
}
/**
* @param name fully qualified file name, e.g. java/lang/String
* @param suffix file name ends with suffix, e.g. .java
* @return byte array for file on class path
*/
public byte[] getBytes( String name, String suffix ) throws IOException {
DataInputStream dis = null;
try {
InputStream is = getInputStream(name, suffix);
if (is == null) {
throw new IOException("Couldn't find: " + name + suffix);
}
dis = new DataInputStream(is);
byte[] bytes = new byte[is.available()];
dis.readFully(bytes);
return bytes;
} finally {
if (dis != null) {
dis.close();
}
}
}
/**
* @return byte array for class
*/
public byte[] getBytes( String name ) throws IOException {
return getBytes(name, ".class");
}
/**
* @param name name of file to search for, e.g. java/lang/String.java
* @return full (canonical) path for file
*/
public String getPath( String name ) throws IOException {
int index = name.lastIndexOf('.');
String suffix = "";
if (index > 0) {
suffix = name.substring(index);
name = name.substring(0, index);
}
return getPath(name, suffix);
}
/**
* @param name name of file to search for, e.g. java/lang/String
* @param suffix file name suffix, e.g. .java
* @return full (canonical) path for file, if it exists
*/
public String getPath( String name, String suffix ) throws IOException {
return getClassFile(name, suffix).getPath();
}
private static abstract class PathEntry implements Serializable {
abstract ClassFile getClassFile( String name, String suffix ) throws IOException;
}
/** Contains information about file/ZIP entry of the Java class.
*/
public interface ClassFile {
/** @return input stream for class file.
*/
public abstract InputStream getInputStream() throws IOException;
/** @return canonical path to class file.
*/
public abstract String getPath();
/** @return base path of found class, i.e. class is contained relative
* to that path, which may either denote a directory, or zip file
*/
public abstract String getBase();
/** @return modification time of class file.
*/
public abstract long getTime();
/** @return size of class file.
*/
public abstract long getSize();
}
private static class Dir extends PathEntry {
private String dir;
Dir(String d) {
dir = d;
}
ClassFile getClassFile( String name, String suffix ) throws IOException {
final File file = new File(dir + File.separatorChar
+ name.replace('.', File.separatorChar) + suffix);
return file.exists() ? new ClassFile() {
public InputStream getInputStream() throws IOException {
return new FileInputStream(file);
}
public String getPath() {
try {
return file.getCanonicalPath();
} catch (IOException e) {
return null;
}
}
public long getTime() {
return file.lastModified();
}
public long getSize() {
return file.length();
}
public String getBase() {
return dir;
}
} : null;
}
public String toString() {
return dir;
}
}
private static class Zip extends PathEntry {
private ZipFile zip;
Zip(ZipFile z) {
zip = z;
}
ClassFile getClassFile( String name, String suffix ) throws IOException {
final ZipEntry entry = zip.getEntry(name.replace('.', '/') + suffix);
return (entry != null) ? new ClassFile() {
public InputStream getInputStream() throws IOException {
return zip.getInputStream(entry);
}
public String getPath() {
return entry.toString();
}
public long getTime() {
return entry.getTime();
}
public long getSize() {
return entry.getSize();
}
public String getBase() {
return zip.getName();
}
} : null;
}
}
}