/**
* Create a class loader based on the SimpleLoader
*
* @param parent parent class loader
* @param path traditional classpath
* @param prefix the class prefix restriction
* @return the new ClassLoader
*/
public static DynamicClassLoader create(ClassLoader parent, Path path, String prefix) {
DynamicClassLoader loader = new DynamicClassLoader(parent, false);
SimpleLoader simpleLoader = new SimpleLoader(loader, path, prefix);
simpleLoader.init();
loader.addLoader(simpleLoader);
loader.init();
return loader;
}
/** Returns the enhanced .class or null if no enhancement. */
public byte[] transform(
ClassLoader loader,
String className,
Class<?> oldClass,
ProtectionDomain domain,
byte[] buffer) {
if (isClassMatch(className)) {
try {
ClassLoader tempLoader = ((DynamicClassLoader) loader).getNewTempClassLoader();
DynamicClassLoader workLoader = SimpleLoader.create(tempLoader, getPostWorkPath());
workLoader.setServletHack(true);
boolean isModified = true;
Thread thread = Thread.currentThread();
ClassLoader oldLoader = thread.getContextClassLoader();
try {
Class<?> cl = Class.forName(className.replace('/', '.'), false, workLoader);
thread.setContextClassLoader(tempLoader);
Method init = cl.getMethod("_caucho_init", new Class[] {Path.class});
Method modified = cl.getMethod("_caucho_is_modified", new Class[0]);
init.invoke(null, Vfs.lookup());
isModified = (Boolean) modified.invoke(null);
} catch (Exception e) {
log.log(Level.FINEST, e.toString(), e);
} catch (Throwable e) {
log.log(Level.FINER, e.toString(), e);
} finally {
thread.setContextClassLoader(oldLoader);
}
if (!isModified) {
try {
return load(className);
} catch (Exception e) {
log.log(Level.FINER, e.toString(), e);
}
}
ByteCodeParser parser = new ByteCodeParser();
parser.setClassLoader(_jClassLoader);
ByteArrayInputStream is;
is = new ByteArrayInputStream(buffer, 0, buffer.length);
JavaClass jClass = parser.parse(is);
return enhance(jClass);
} catch (RuntimeException e) {
throw e;
} catch (Exception e) {
throw new EnhancerRuntimeException(e);
}
}
return null;
}
/**
* Loads the compiled stylesheet .class file
*
* @param className the mangled classname for the stylesheet
*/
protected StylesheetImpl loadStylesheet(String systemId, String className) throws Exception {
LruCache<String, SoftReference<StylesheetImpl>> cache;
ClassLoader parentLoader = Thread.currentThread().getContextClassLoader();
cache = _stylesheetCache.getLevel(parentLoader);
if (cache == null) {
cache = new LruCache<String, SoftReference<StylesheetImpl>>(256);
_stylesheetCache.set(cache, parentLoader);
}
SoftReference<StylesheetImpl> stylesheetRef;
stylesheetRef = cache.get(className);
StylesheetImpl stylesheet = null;
if (stylesheetRef != null) stylesheet = stylesheetRef.get();
try {
if (stylesheet != null && !stylesheet.isModified()) return stylesheet;
} catch (Throwable e) {
log.log(Level.FINER, e.toString(), e);
}
Path classPath = getWorkPath().lookup(className.replace('.', '/') + ".class");
if (!classPath.canRead())
throw new ClassNotFoundException("can't find compiled XSL `" + className + "'");
DynamicClassLoader loader;
loader = SimpleLoader.create(parentLoader, getWorkPath(), className);
Class cl = null;
// If the loading fails, remove the class because it may be corrupted
try {
cl = CauchoSystem.loadClass(className, false, loader);
} catch (Error e) {
try {
classPath.remove();
} catch (IOException e1) {
log.log(Level.FINE, e1.toString(), e1);
}
throw e;
}
stylesheet = (StylesheetImpl) cl.newInstance();
Path path;
path = getSearchPath().lookup("").lookup(systemId);
/*
try {
} catch (TransformerException e) {
log.log(Level.FINE, e.toString(), e);
path = Vfs.lookup(systemId);
}
*/
// stylesheet.init(path);
stylesheet.init(getStylePath());
stylesheet.setURIResolver(_uriResolver);
stylesheetRef = new SoftReference<StylesheetImpl>(stylesheet);
cache.put(className, stylesheetRef);
return stylesheet;
}
