@Override
public ArtifactBuilder buildArtifacts(
BaseArtifactType primaryArtifact, ArtifactContent artifactContent) throws IOException {
super.buildArtifacts(primaryArtifact, artifactContent);
ClassParser parser = new ClassParser(getContentStream(), primaryArtifact.getName());
JavaClass javaClass = parser.parse();
if (javaClass.isInterface()) {
((ExtendedDocument) primaryArtifact).setExtendedType(JavaModel.TYPE_JAVA_INTERFACE);
} else if (javaClass.isClass()) {
((ExtendedDocument) primaryArtifact).setExtendedType(JavaModel.TYPE_JAVA_CLASS);
} else if (javaClass.isEnum()) {
((ExtendedDocument) primaryArtifact).setExtendedType(JavaModel.TYPE_JAVA_ENUM);
}
String packageName = javaClass.getPackageName();
String className = javaClass.getClassName();
primaryArtifact.setName(className);
String shortName = className;
if (className.lastIndexOf('.') > 0) {
shortName = className.substring(className.lastIndexOf('.') + 1);
}
SrampModelUtils.setCustomProperty(primaryArtifact, JavaModel.PROP_PACKAGE_NAME, packageName);
SrampModelUtils.setCustomProperty(primaryArtifact, JavaModel.PROP_CLASS_NAME, shortName);
return this;
}
public void visitJavaClass(JavaClass clazz) {
super.visitJavaClass(clazz);
JopClassInfo cli = (JopClassInfo) this.cli;
cpool = clazz.getConstantPool();
if (clazz.isInterface()) {
cli.interfaceID = ++cli.interfaceCnt;
cli.interfaceList.add(cli.interfaceID - 1, clazz.getClassName());
}
}
/**
* implements the detector to collect the super classes
*
* @param classContext the context object for the currently parsed class
*/
@Override
public void visitClassContext(ClassContext classContext) {
try {
clsContext = classContext;
JavaClass cls = classContext.getJavaClass();
if (cls.isInterface()) return;
superClasses = cls.getSuperClasses();
cls.accept(this);
} catch (ClassNotFoundException cnfe) {
bugReporter.reportMissingClass(cnfe);
} finally {
clsContext = null;
superClasses = null;
}
}
/**
* Dumps the contents of the specified class to the specified directory. The file is named
* dump_dir/[class].bcel. It contains a synopsis of the fields and methods followed by the jvm
* code for each method.
*
* @param jc javaclass to dump
* @param dump_dir directory in which to write the file
*/
public static void dump(JavaClass jc, File dump_dir) {
try {
dump_dir.mkdir();
File path = new File(dump_dir, jc.getClassName() + ".bcel");
PrintStream p = new PrintStream(path);
// Print the class, super class and interfaces
p.printf("class %s extends %s\n", jc.getClassName(), jc.getSuperclassName());
String[] inames = jc.getInterfaceNames();
if ((inames != null) && (inames.length > 0)) {
p.printf(" ");
for (String iname : inames) p.printf("implements %s ", iname);
p.printf("\n");
}
// Print each field
p.printf("\nFields\n");
for (Field f : jc.getFields()) p.printf(" %s\n", f);
// Print the signature of each method
p.printf("\nMethods\n");
for (Method m : jc.getMethods()) p.printf(" %s\n", m);
// If this is not an interface, print the code for each method
if (!jc.isInterface()) {
for (Method m : jc.getMethods()) {
p.printf("\nMethod %s\n", m);
Code code = m.getCode();
if (code != null) p.printf(" %s\n", code.toString().replace("\n", "\n "));
}
}
// Print the details of the constant pool.
p.printf("Constant Pool:\n");
ConstantPool cp = jc.getConstantPool();
Constant[] constants = cp.getConstantPool();
for (int ii = 0; ii < constants.length; ii++) {
p.printf(" %d %s\n", ii, constants[ii]);
}
p.close();
} catch (Exception e) {
throw new Error("Unexpected error dumping javaclass", e);
}
}
private static boolean containsConcreteClasses(Set<JavaClass> s) {
for (JavaClass c : s) if (!c.isInterface() && !c.isAbstract()) return true;
return false;
}
public static double isDeepSerializable(JavaClass x) throws ClassNotFoundException {
if (storedException != null) throw storedException;
if (x.getClassName().equals("java.lang.Object")) return 0.4;
if (DEBUG) {
System.out.println("checking " + x.getClassName());
}
double result = Analyze.deepInstanceOf(x, serializable);
if (result >= 0.9) {
if (DEBUG) {
System.out.println("Direct high serializable result: " + result);
}
return result;
}
if (x.isFinal()) return result;
double collectionResult = Analyze.deepInstanceOf(x, collection);
double mapResult = Analyze.deepInstanceOf(x, map);
if (x.isInterface() || x.isAbstract()) {
result = Math.max(result, Math.max(mapResult, collectionResult) * 0.95);
if (result >= 0.9) {
return result;
}
}
ClassDescriptor classDescriptor = DescriptorFactory.createClassDescriptor(x);
Subtypes2 subtypes2 = AnalysisContext.currentAnalysisContext().getSubtypes2();
Set<ClassDescriptor> directSubtypes = subtypes2.getDirectSubtypes(classDescriptor);
directSubtypes.remove(classDescriptor);
double confidence = 0.6;
if (x.isAbstract() || x.isInterface()) {
confidence = 0.8;
result = Math.max(result, 0.4);
} else if (directSubtypes.isEmpty()) confidence = 0.2;
double confidence2 = (1 + confidence) / 2;
result = Math.max(result, confidence2 * collectionResult);
if (result >= 0.9) {
if (DEBUG) {
System.out.println("High collection result: " + result);
}
return result;
}
result = Math.max(result, confidence2 * mapResult);
if (result >= 0.9) {
if (DEBUG) {
System.out.println("High map result: " + result);
}
return result;
}
result = Math.max(result, confidence2 * 0.5 * Analyze.deepInstanceOf(x, comparator));
if (result >= 0.9) {
if (DEBUG) {
System.out.println("High comparator result: " + result);
}
return result;
}
for (ClassDescriptor subtype : directSubtypes) {
JavaClass subJavaClass = Repository.lookupClass(subtype.getDottedClassName());
result = Math.max(result, confidence * Analyze.deepInstanceOf(subJavaClass, serializable));
// result = Math.max(result, confidence * isDeepSerializable(subJavaClass));
if (result >= 0.9) {
return result;
}
}
if (DEBUG) {
System.out.println("No high results; max: " + result);
}
return result;
}