/***
* Extracted and modified from ASM 4 test suite. Original copyright notice preserved below
*
* ASM tests
* Copyright (c) 2000-2011 INRIA, France Telecom
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
* THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.pitest.classinfo;
import java.util.Map;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.ClassWriter;
import org.objectweb.asm.Opcodes;
/**
* A ClassWriter that computes the common super class of two classes without
* actually loading them with a ClassLoader.
*
* @author Eric Bruneton
*
* Modified to match behaviour of default ClassWriter and cache already
* calculated values
*/
public class ComputeClassWriter extends ClassWriter {
private final ClassByteArraySource bytes;
private final Map<String, String> cache;
public ComputeClassWriter(final ClassByteArraySource bytes,
final Map<String, String> cache, final int flags) {
super(flags);
this.bytes = bytes;
this.cache = cache;
}
@Override
protected String getCommonSuperClass(final String type1, final String type2) {
final String key = type1 + "!_!" + type2;
final String previous = this.cache.get(key);
if (previous != null) {
return previous;
}
final ClassReader info1 = typeInfo(type1);
final ClassReader info2 = typeInfo(type2);
final String result = getCommonSuperClass(type1, info1, type2, info2);
this.cache.put(key, result);
return result;
}
private String getCommonSuperClass(final String type1,
final ClassReader info1, final String type2, final ClassReader info2) {
if (isInterface(info1)) {
if (typeImplements(type2, info2, type1)) {
return type1;
} else {
if (isInterface(info2)) {
if (typeImplements(type1, info1, type2)) {
return type2;
} else {
return "java/lang/Object";
}
}
}
}
final StringBuilder b1 = typeAncestors(type1, info1);
final StringBuilder b2 = typeAncestors(type2, info2);
String result = "java/lang/Object";
int end1 = b1.length();
int end2 = b2.length();
while (true) {
final int start1 = b1.lastIndexOf(";", end1 - 1);
final int start2 = b2.lastIndexOf(";", end2 - 1);
if ((start1 != -1) && (start2 != -1)
&& ((end1 - start1) == (end2 - start2))) {
final String p1 = b1.substring(start1 + 1, end1);
final String p2 = b2.substring(start2 + 1, end2);
if (p1.equals(p2)) {
result = p1;
end1 = start1;
end2 = start2;
} else {
return result;
}
} else {
return result;
}
}
}
private static boolean isInterface(final ClassReader info1) {
return (info1.getAccess() & Opcodes.ACC_INTERFACE) != 0;
}
/**
* Returns the internal names of the ancestor classes of the given type.
*
* @param type
* the internal name of a class or interface.
* @param info
* the ClassReader corresponding to 'type'.
* @return a StringBuilder containing the ancestor classes of 'type',
* separated by ';'. The returned string has the following format:
* ";type1;type2 ... ;typeN", where type1 is 'type', and typeN is a
* direct subclass of Object. If 'type' is Object, the returned string
* is empty.
*/
private StringBuilder typeAncestors(String type, ClassReader info) {
final StringBuilder b = new StringBuilder();
while (!"java/lang/Object".equals(type)) {
b.append(';').append(type);
type = info.getSuperName();
info = typeInfo(type);
}
return b;
}
/**
* Returns true if the given type implements the given interface.
*
* @param type
* the internal name of a class or interface.
* @param info
* the ClassReader corresponding to 'type'.
* @param itf
* the internal name of a interface.
* @return true if 'type' implements directly or indirectly 'itf'
*/
private boolean typeImplements(String type, ClassReader info, final String itf) {
final String cleanItf = itf.replace(".", "/");
while (!"java/lang/Object".equals(type)) {
final String[] itfs = info.getInterfaces();
for (final String itf2 : itfs) {
if (itf2.equals(cleanItf)) {
return true;
}
}
for (final String itf2 : itfs) {
if (typeImplements(itf2, typeInfo(itf2), cleanItf)) {
return true;
}
}
type = info.getSuperName();
info = typeInfo(type);
}
return false;
}
/**
* Returns a ClassReader corresponding to the given class or interface.
*
* @param type
* the internal name of a class or interface.
* @return the ClassReader corresponding to 'type'.
*/
private ClassReader typeInfo(final String type) {
return new ClassReader(this.bytes.getBytes(type).value());
}
}