private byte[] modifiyClass(byte[] classfile, String name) {
ClassParser parser = new ClassParser(new ByteArrayInputStream(classfile), "");
try {
JavaClass cls = parser.parse();
for (JavaClassModifier modifier :
ConfigurationLoader.getInstance().getJavaClassModifierList()) {
modifier.modify(cls);
}
ByteArrayOutputStream out = new ByteArrayOutputStream();
cls.dump(out);
return out.toByteArray();
} catch (Exception e) {
throw new RuntimeException("Error while modifying class '" + name + "'", e);
}
}
/**
* Given another class, return a transformed version of the class which replaces specified calls
* with alternative static implementations
*/
public byte[] transform(
ClassLoader loader,
String className,
Class<?> classBeingRedefined,
ProtectionDomain protectionDomain,
byte[] classfileBuffer)
throws IllegalClassFormatException {
// debug = className.equals ("chicory/Test");
String fullClassName = className.replace("/", ".");
debug_transform.log("In Transform: class = %s%n", className);
// Don't instrument boot classes. We only want to instrument
// user classes classpath.
// Most boot classes have the null loader,
// but some generated classes (such as those in sun.reflect) will
// have a non-null loader. Some of these have a null parent loader,
// but some do not. The check for the sun.reflect package is a hack
// to catch all of these. A more consistent mechanism to determine
// boot classes would be preferrable.
if (loader == null) {
debug_transform.log("ignoring system class %s, class loader == null", fullClassName);
return (null);
} else if (loader.getParent() == null) {
debug_transform.log("ignoring system class %s, parent loader == null\n", fullClassName);
return (null);
} else if (fullClassName.startsWith("sun.reflect")) {
debug_transform.log("ignoring system class %s, in sun.reflect package", fullClassName);
return (null);
} else if (fullClassName.startsWith("com.sun")) {
System.out.printf("Class from com.sun package %s with nonnull loaders\n", fullClassName);
}
// Don't intrument our code
if (className.startsWith("randoop.")) {
debug_transform.log("Not considering randoop class %s%n", fullClassName);
return (null);
}
// Look for match with specified regular expressions for class
method_map = null;
debug_class = false;
for (MethodMapInfo mmi : map_list) {
if (mmi.class_regex.matcher(className).matches()) {
if (false && className.startsWith("RandoopTest")) debug_class = true;
if (debug_class)
System.out.printf("Classname %s matches re %s%n", className, mmi.class_regex);
method_map = mmi.map;
break;
}
}
if (method_map == null) return null;
debug_transform.log(
"transforming class %s, loader %s - %s%n", className, loader, loader.getParent());
// Parse the bytes of the classfile, die on any errors
JavaClass c = null;
ClassParser parser = new ClassParser(new ByteArrayInputStream(classfileBuffer), className);
try {
c = parser.parse();
} catch (Exception e) {
throw new RuntimeException("Unexpected error", e);
}
try {
// Get the class information
ClassGen cg = new ClassGen(c);
ifact = new InstructionFactory(cg);
map_calls(cg, className, loader);
JavaClass njc = cg.getJavaClass();
if (debug) njc.dump("/tmp/ret/" + njc.getClassName() + ".class");
if (true) {
return (cg.getJavaClass().getBytes());
} else {
debug_transform.log("not including class %s (filtered out)", className);
return null;
}
} catch (Throwable e) {
out.format("Unexpected error %s in transform", e);
e.printStackTrace();
return (null);
}
}