> annotations = new ArrayList<>();
for (int index = 0; index < (invisibleParameterAnnotationsCount < 0
? methodTypeDesc.parameterCount()
: invisibleParameterAnnotationsCount); index++) {
annotations.add(invisibleParameterAnnotations.getOrDefault(index, List.of()));
}
methodBuilder.with(RuntimeInvisibleParameterAnnotationsAttribute.of(annotations));
}
if (codeConsumers != null) {
undelayInstruction();
methodBuilder.withCode(codeBuilder -> {
codeConsumers.forEach(codeConsumer -> codeConsumer.accept(codeBuilder));
if (!stackMapFrames.isEmpty()) {
codeBuilder.with(StackMapTableAttribute.of(stackMapFrames));
}
for (CodeElement attribute : codeAttributes) {
codeBuilder.with(attribute);
}
});
}
}));
}
}
@Override
public void visitEnd() {
ClassFile classFile;
if ((flags & ClassWriter.COMPUTE_FRAMES) == 0) {
classFile = ClassFile.of(ClassFile.DeadCodeOption.KEEP_DEAD_CODE, ClassFile.StackMapsOption.DROP_STACK_MAPS);
} else {
classFile = ClassFile.of(ClassFile.DeadCodeOption.PATCH_DEAD_CODE, ClassFile.StackMapsOption.STACK_MAPS_WHEN_REQUIRED, ClassFile.ClassHierarchyResolverOption.of(classDesc -> {
if (!classDesc.isClassOrInterface()) {
return null;
} else if (classDesc.equals(ConstantDescs.CD_Object)) {
return ClassHierarchyResolver.ClassHierarchyInfo.ofClass(null);
}
String superClass = getSuperClass(classDesc.displayName().replace('.', '/'));
return superClass == null ? ClassHierarchyResolver.ClassHierarchyInfo.ofInterface() : ClassHierarchyResolver.ClassHierarchyInfo.ofClass(ClassDesc.ofInternalName(superClass));
}));
}
if (classModel == null) {
bytes = classFile.build(thisClass, classBuilder -> classConsumers.forEach(classConsumer -> classConsumer.accept(classBuilder)));
} else {
ConstantPoolBuilder constantPoolBuilder = ConstantPoolBuilder.of(classModel);
bytes = classFile.build(constantPoolBuilder.classEntry(thisClass), constantPoolBuilder, classBuilder -> classConsumers.forEach(classConsumer -> classConsumer.accept(classBuilder)));
}
}
static ConstantDesc toConstantDesc(Object asm) {
return switch (asm) {
case Integer value -> value;
case Long value -> value;
case Float value -> value;
case Double value -> value;
case String value -> value;
case Type value -> switch (value.getSort()) {
case Type.OBJECT, Type.ARRAY -> ClassDesc.ofDescriptor(value.getDescriptor());
case Type.METHOD -> MethodTypeDesc.ofDescriptor(value.getDescriptor());
default -> throw new IllegalArgumentException("Unexpected type sort: " + value.getSort());
};
case Handle value ->
MethodHandleDesc.of(DirectMethodHandleDesc.Kind.valueOf(value.getTag(), value.isInterface()), ClassDesc.ofInternalName(value.getOwner()), value.getName(), value.getDesc());
case ConstantDynamic value -> {
ConstantDesc[] constants = new ConstantDesc[value.getBootstrapMethodArgumentCount()];
for (int index = 0; index < value.getBootstrapMethodArgumentCount(); index++) {
constants[index] = toConstantDesc(value.getBootstrapMethodArgument(index));
}
yield DynamicConstantDesc.ofNamed(MethodHandleDesc.of(DirectMethodHandleDesc.Kind.valueOf(value.getBootstrapMethod().getTag(), value.getBootstrapMethod().isInterface()), ClassDesc.ofInternalName(value.getBootstrapMethod().getOwner()), value.getBootstrapMethod().getName(), value.getBootstrapMethod().getDesc()), value.getName(), ClassDesc.ofDescriptor(value.getDescriptor()), constants);
}
case null, default -> throw new IllegalArgumentException("Unexpected constant: " + asm);
};
}
/**
* Returns the generated class file.
*
* @return The class file as a byte array.
*/
public byte[] toByteArray() {
if (bytes == null) {
throw new IllegalStateException("Did not visitEnd, and no byte array was created");
}
return bytes;
}
/**
* Returns the super class of the class that is provided by name. The default implementation
* resolves the super class from this instance's class' {@link ClassLoader}, unless
* {@link #getClassLoader()} is overridden.
*
* This is used for generating stack map frames.
*
* @param name The name of the class for which to resolve the super class.
* @return The name of the resolved super class.
*/
protected String getSuperClass(String name) {
if (getSuperClass != null) {
return getSuperClass.apply(name);
}
ClassLoader classLoader = getClassLoader();
Class type;
try {
type = Class.forName(name.replace('/', '.'), false, classLoader);
} catch (ClassNotFoundException e) {
throw new TypeNotPresentException(name.replace('/', '.'), e);
}
if (type.isInterface()) {
return null;
} else {
return Type.getInternalName(type.getSuperclass());
}
}
/**
* Returns the class loader to use for resolving the super class of a discovered class.
*
* @return The class loader to use for resolving a super class's name.
*/
protected ClassLoader getClassLoader() {
return getClass().getClassLoader();
}
class WritingAnnotationVisitor extends AnnotationVisitor {
private final BiConsumer consumer;
private final Runnable onEnd;
private static AnnotationVisitor of(JdkClassWriter classWriter, String descriptor, Consumer consumer) {
List elements = new ArrayList<>();
return classWriter.new WritingAnnotationVisitor((name, value) -> elements.add(AnnotationElement.of(name, value)), () -> consumer.accept(Annotation.of(ClassDesc.ofDescriptor(descriptor), elements)));
}
private static AnnotationVisitor ofValue(JdkClassWriter classWriter, Consumer consumer) {
return classWriter.new WritingAnnotationVisitor((_, value) -> consumer.accept(value), () -> {
});
}
private static AnnotationVisitor ofTypeAnnotation(JdkClassWriter classWriter, String descriptor, int typeRef, TypePath typePath, Consumer consumer) {
return ofUnresolvedTypeAnnotation(classWriter, descriptor, typeRef, typePath, function -> consumer.accept(function.apply(reference -> switch (reference.getSort()) {
case TypeReference.CLASS_TYPE_PARAMETER ->
TypeAnnotation.TargetInfo.ofClassTypeParameter(reference.getTypeParameterIndex());
case TypeReference.METHOD_TYPE_PARAMETER ->
TypeAnnotation.TargetInfo.ofMethodTypeParameter(reference.getTypeParameterIndex());
case TypeReference.CLASS_EXTENDS ->
TypeAnnotation.TargetInfo.ofClassExtends(reference.getSuperTypeIndex());
case TypeReference.CLASS_TYPE_PARAMETER_BOUND ->
TypeAnnotation.TargetInfo.ofClassTypeParameterBound(reference.getTypeParameterIndex(), reference.getTypeParameterBoundIndex());
case TypeReference.METHOD_TYPE_PARAMETER_BOUND ->
TypeAnnotation.TargetInfo.ofMethodTypeParameterBound(reference.getTypeParameterIndex(), reference.getTypeParameterBoundIndex());
case TypeReference.FIELD -> TypeAnnotation.TargetInfo.ofField();
case TypeReference.METHOD_RETURN -> TypeAnnotation.TargetInfo.ofMethodReturn();
case TypeReference.METHOD_RECEIVER -> TypeAnnotation.TargetInfo.ofMethodReceiver();
case TypeReference.METHOD_FORMAL_PARAMETER ->
TypeAnnotation.TargetInfo.ofMethodFormalParameter(reference.getFormalParameterIndex());
case TypeReference.THROWS -> TypeAnnotation.TargetInfo.ofThrows(reference.getExceptionIndex());
default -> throw new IllegalArgumentException("Unexpected reference sort: " + reference.getSort());
})));
}
private static AnnotationVisitor ofExceptionTypeAnnotation(JdkClassWriter classWriter, String descriptor, int typeRef, TypePath typePath, Consumer> consumer) {
return ofUnresolvedTypeAnnotation(classWriter, descriptor, typeRef, typePath, function -> consumer.accept(index -> function.apply(reference -> switch (reference.getSort()) {
case TypeReference.EXCEPTION_PARAMETER -> TypeAnnotation.TargetInfo.ofExceptionParameter(index);
default -> throw new IllegalArgumentException("Unexpected reference sort: " + reference.getSort());
})));
}
private static AnnotationVisitor ofLabeledTypeAnnotation(JdkClassWriter classWriter, String descriptor, int typeRef, TypePath typePath, Consumer> consumer) {
return ofUnresolvedTypeAnnotation(classWriter, descriptor, typeRef, typePath, function -> consumer.accept(label -> function.apply(reference -> switch (reference.getSort()) {
case TypeReference.INSTANCEOF -> TypeAnnotation.TargetInfo.ofInstanceofExpr(label);
case TypeReference.NEW -> TypeAnnotation.TargetInfo.ofNewExpr(label);
case TypeReference.CONSTRUCTOR_REFERENCE -> TypeAnnotation.TargetInfo.ofConstructorReference(label);
case TypeReference.METHOD_REFERENCE -> TypeAnnotation.TargetInfo.ofMethodReference(label);
case TypeReference.CAST ->
TypeAnnotation.TargetInfo.ofCastExpr(label, reference.getTypeArgumentIndex());
case TypeReference.CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT ->
TypeAnnotation.TargetInfo.ofConstructorInvocationTypeArgument(label, reference.getTypeArgumentIndex());
case TypeReference.METHOD_INVOCATION_TYPE_ARGUMENT ->
TypeAnnotation.TargetInfo.ofMethodInvocationTypeArgument(label, reference.getTypeArgumentIndex());
case TypeReference.CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT ->
TypeAnnotation.TargetInfo.ofConstructorReferenceTypeArgument(label, reference.getTypeArgumentIndex());
case TypeReference.METHOD_REFERENCE_TYPE_ARGUMENT ->
TypeAnnotation.TargetInfo.ofMethodReferenceTypeArgument(label, reference.getTypeArgumentIndex());
default -> throw new IllegalArgumentException("Unexpected reference sort: " + reference.getSort());
})));
}
private static AnnotationVisitor ofTargetedTypeAnnotation(JdkClassWriter classWriter, String descriptor, int typeRef, TypePath typePath, Consumer, TypeAnnotation>> consumer) {
return ofUnresolvedTypeAnnotation(classWriter, descriptor, typeRef, typePath, function -> consumer.accept(targets -> function.apply(reference -> switch (reference.getSort()) {
case TypeReference.LOCAL_VARIABLE -> TypeAnnotation.TargetInfo.ofLocalVariable(targets);
case TypeReference.RESOURCE_VARIABLE -> TypeAnnotation.TargetInfo.ofResourceVariable(targets);
default -> throw new IllegalArgumentException("Unexpected reference sort: " + reference.getSort());
})));
}
private static AnnotationVisitor ofUnresolvedTypeAnnotation(JdkClassWriter classWriter, String descriptor, int typeRef, TypePath typePath, Consumer, TypeAnnotation>> consumer) {
List elements = new ArrayList<>();
List components;
if (typePath == null) {
components = List.of();
} else {
components = new ArrayList<>(typePath.getLength());
for (int index = 0; index < typePath.getLength(); index++) {
components.add(switch (typePath.getStep(index)) {
case TypePath.ARRAY_ELEMENT -> TypeAnnotation.TypePathComponent.ARRAY;
case TypePath.INNER_TYPE -> TypeAnnotation.TypePathComponent.INNER_TYPE;
case TypePath.WILDCARD_BOUND -> TypeAnnotation.TypePathComponent.WILDCARD;
case TypePath.TYPE_ARGUMENT ->
TypeAnnotation.TypePathComponent.of(TypeAnnotation.TypePathComponent.Kind.TYPE_ARGUMENT, typePath.getStepArgument(index));
default ->
throw new IllegalArgumentException("Unkniwn type path type: " + typePath.getStep(index));
});
}
}
TypeReference reference = new TypeReference(typeRef);
return classWriter.new WritingAnnotationVisitor((name, value) -> elements.add(AnnotationElement.of(name, value)), () -> consumer.accept(targeting -> TypeAnnotation.of(targeting.apply(reference), components, Annotation.of(ClassDesc.ofDescriptor(descriptor), elements))));
}
private WritingAnnotationVisitor(BiConsumer consumer, Runnable onEnd) {
super(Opcodes.ASM9);
this.consumer = consumer;
this.onEnd = onEnd;
}
boolean has(ClassModel classModel) {
return Objects.equals(JdkClassWriter.this.classModel, classModel);
}
void add(String name, AnnotationValue annotationValue) {
consumer.accept(name, annotationValue);
}
@Override
public void visit(String name, Object asm) {
consumer.accept(name, switch (asm) {
case Boolean value -> AnnotationValue.ofBoolean(value);
case Byte value -> AnnotationValue.ofByte(value);
case Short value -> AnnotationValue.ofShort(value);
case Character value -> AnnotationValue.ofChar(value);
case Integer value -> AnnotationValue.ofInt(value);
case Long value -> AnnotationValue.ofLong(value);
case Float value -> AnnotationValue.ofFloat(value);
case Double value -> AnnotationValue.ofDouble(value);
case String value -> AnnotationValue.ofString(value);
case boolean[] array -> {
AnnotationValue[] values = new AnnotationValue[array.length];
for (int index = 0; index < array.length; index++) {
values[index] = AnnotationValue.ofBoolean(array[index]);
}
yield AnnotationValue.ofArray(values);
}
case byte[] array -> {
AnnotationValue[] values = new AnnotationValue[array.length];
for (int index = 0; index < array.length; index++) {
values[index] = AnnotationValue.ofByte(array[index]);
}
yield AnnotationValue.ofArray(values);
}
case short[] array -> {
AnnotationValue[] values = new AnnotationValue[array.length];
for (int index = 0; index < array.length; index++) {
values[index] = AnnotationValue.ofShort(array[index]);
}
yield AnnotationValue.ofArray(values);
}
case char[] array -> {
AnnotationValue[] values = new AnnotationValue[array.length];
for (int index = 0; index < array.length; index++) {
values[index] = AnnotationValue.ofChar(array[index]);
}
yield AnnotationValue.ofArray(values);
}
case int[] array -> {
AnnotationValue[] values = new AnnotationValue[array.length];
for (int index = 0; index < array.length; index++) {
values[index] = AnnotationValue.ofInt(array[index]);
}
yield AnnotationValue.ofArray(values);
}
case long[] array -> {
AnnotationValue[] values = new AnnotationValue[array.length];
for (int index = 0; index < array.length; index++) {
values[index] = AnnotationValue.ofLong(array[index]);
}
yield AnnotationValue.ofArray(values);
}
case float[] array -> {
AnnotationValue[] values = new AnnotationValue[array.length];
for (int index = 0; index < array.length; index++) {
values[index] = AnnotationValue.ofFloat(array[index]);
}
yield AnnotationValue.ofArray(values);
}
case double[] array -> {
AnnotationValue[] values = new AnnotationValue[array.length];
for (int index = 0; index < array.length; index++) {
values[index] = AnnotationValue.ofDouble(array[index]);
}
yield AnnotationValue.ofArray(values);
}
case String[] array -> {
AnnotationValue[] values = new AnnotationValue[array.length];
for (int index = 0; index < array.length; index++) {
values[index] = AnnotationValue.ofString(array[index]);
}
yield AnnotationValue.ofArray(values);
}
case Type type -> AnnotationValue.ofClass(ClassDesc.ofDescriptor(type.getDescriptor()));
case null, default -> throw new IllegalArgumentException("Unknown annotation value: " + asm);
});
}
@Override
public void visitEnum(String name, String descriptor, String value) {
consumer.accept(name, AnnotationValue.ofEnum(ClassDesc.ofDescriptor(descriptor), value));
}
@Override
public AnnotationVisitor visitAnnotation(String name, String descriptor) {
return WritingAnnotationVisitor.of(JdkClassWriter.this, descriptor, annotation -> consumer.accept(name, AnnotationValue.ofAnnotation(annotation)));
}
@Override
public AnnotationVisitor visitArray(String name) {
List values = new ArrayList<>();
return new WritingAnnotationVisitor((_, value) -> values.add(value), () -> consumer.accept(name, AnnotationValue.ofArray(values)));
}
@Override
public void visitEnd() {
onEnd.run();
}
}
}
asm-jdk-bridge-0.0.10/asm-jdk-bridge/src/main/java-9/ 0000775 0000000 0000000 00000000000 15023613512 0021730 5 ustar 00root root 0000000 0000000 asm-jdk-bridge-0.0.10/asm-jdk-bridge/src/main/java-9/codes/ 0000775 0000000 0000000 00000000000 15023613512 0023025 5 ustar 00root root 0000000 0000000 asm-jdk-bridge-0.0.10/asm-jdk-bridge/src/main/java-9/codes/rafael/ 0000775 0000000 0000000 00000000000 15023613512 0024257 5 ustar 00root root 0000000 0000000 asm-jdk-bridge-0.0.10/asm-jdk-bridge/src/main/java-9/codes/rafael/asmjdkbridge/ 0000775 0000000 0000000 00000000000 15023613512 0026705 5 ustar 00root root 0000000 0000000 asm-jdk-bridge-0.0.10/asm-jdk-bridge/src/main/java-9/codes/rafael/asmjdkbridge/Dummy.java 0000664 0000000 0000000 00000000064 15023613512 0030643 0 ustar 00root root 0000000 0000000 package codes.rafael.asmjdkbridge;
class Dummy {
}
asm-jdk-bridge-0.0.10/asm-jdk-bridge/src/main/java-9/module-info.java 0000664 0000000 0000000 00000000154 15023613512 0025011 0 ustar 00root root 0000000 0000000 module codes.rafael.asmjdkbridge {
requires org.objectweb.asm;
exports codes.rafael.asmjdkbridge;
}
asm-jdk-bridge-0.0.10/asm-jdk-bridge/src/main/java/ 0000775 0000000 0000000 00000000000 15023613512 0021562 5 ustar 00root root 0000000 0000000 asm-jdk-bridge-0.0.10/asm-jdk-bridge/src/main/java/codes/ 0000775 0000000 0000000 00000000000 15023613512 0022657 5 ustar 00root root 0000000 0000000 asm-jdk-bridge-0.0.10/asm-jdk-bridge/src/main/java/codes/rafael/ 0000775 0000000 0000000 00000000000 15023613512 0024111 5 ustar 00root root 0000000 0000000 asm-jdk-bridge-0.0.10/asm-jdk-bridge/src/main/java/codes/rafael/asmjdkbridge/ 0000775 0000000 0000000 00000000000 15023613512 0026537 5 ustar 00root root 0000000 0000000 asm-jdk-bridge-0.0.10/asm-jdk-bridge/src/main/java/codes/rafael/asmjdkbridge/JdkClassReader.java 0000664 0000000 0000000 00000005677 15023613512 0032242 0 ustar 00root root 0000000 0000000 package codes.rafael.asmjdkbridge;
import org.objectweb.asm.Attribute;
import org.objectweb.asm.ClassVisitor;
import org.objectweb.asm.Type;
import java.io.IOException;
import java.io.InputStream;
/**
* A reader for class files that uses the JDK class file API. The created class reader is immutable.
*/
public class JdkClassReader {
/**
* Creates a new class reader.
*
* @param classFile The class file to represent.
* @param attributePrototypes Prototypes of ASM attributes to map if discovered.
*/
public JdkClassReader(byte[] classFile, Attribute... attributePrototypes) {
throw new UnsupportedOperationException();
}
/**
* Creates a new class reader.
*
* @param inputStream An input stream of the class file to represent.
* @param attributePrototypes Prototypes of ASM attributes to map if discovered.
* @throws IOException If the stream cannot be read.
*/
public JdkClassReader(InputStream inputStream, Attribute... attributePrototypes) throws IOException {
throw new UnsupportedOperationException();
}
/**
* Creates a new class reader.
*
* @param className The name of the class to represent. The class must be resolvable from the system loader.
* @param attributePrototypes Prototypes of ASM attributes to map if discovered.
* @throws IOException If the class file cannot be read.
*/
public JdkClassReader(String className, Attribute... attributePrototypes) throws IOException {
throw new UnsupportedOperationException();
}
/**
* Returns the access flags of this class as stored in the class file.
*
* @return The access flags of this class as stored in the class file.
*/
public int getAccess() {
throw new UnsupportedOperationException();
}
/**
* Returns the internal name of this class.
*
* @return The internal name of this class.
*/
public String getClassName() {
throw new UnsupportedOperationException();
}
/**
* Returns the internal super class name of this class or {@code null} for {@link Object}.
*
* @return The internal super class name of this class or {@code null} for {@link Object}.
*/
public String getSuperName() {
throw new UnsupportedOperationException();
}
/**
* Returns the internal interface names of this class. Maybe {@code null}.
*
* @return The internal interface names of this class.
*/
public String[] getInterfaces() {
throw new UnsupportedOperationException();
}
/**
* Accepts a class visitor for the represented class file.
*
* @param classVisitor The class visitor to delegate calls to.
* @param flags The ASM flags to consider when visiting the class file.
*/
public void accept(ClassVisitor classVisitor, int flags) {
throw new UnsupportedOperationException();
}
}
asm-jdk-bridge-0.0.10/asm-jdk-bridge/src/main/java/codes/rafael/asmjdkbridge/JdkClassWriter.java 0000664 0000000 0000000 00000015571 15023613512 0032306 0 ustar 00root root 0000000 0000000 package codes.rafael.asmjdkbridge;
import org.objectweb.asm.AnnotationVisitor;
import org.objectweb.asm.Attribute;
import org.objectweb.asm.ClassVisitor;
import org.objectweb.asm.FieldVisitor;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.ModuleVisitor;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.RecordComponentVisitor;
import org.objectweb.asm.TypePath;
import java.lang.reflect.Method;
import java.util.function.Function;
/**
* A class visitor that creates a class file which is based upon the JDK Class File API.
*/
public class JdkClassWriter extends ClassVisitor {
/**
* Creates a class writer.
*
* @param flags The ASM flags to consider.
*/
public JdkClassWriter(int flags) {
super(Opcodes.ASM9);
throw new UnsupportedOperationException();
}
/**
* Creates a class writer.
*
* @param classReader A class reader of which to retain the constant pool, if possible.
* @param flags The ASM flags to consider.
*/
public JdkClassWriter(JdkClassReader classReader, int flags) {
super(Opcodes.ASM9);
throw new UnsupportedOperationException();
}
/**
* Creates a class writer.
*
* @param flags The ASM flags to consider.
* @param getSuperClass A resolver for the supplied internal class name's internal super class name. If
* a class is an interface, {@code null} should be returned. As a method to allow
* pre-Java 8 code to call this constructor via reflection.
* @param target The target to invoke the reflective method on.
*/
public JdkClassWriter(int flags, Method getSuperClass, Object target) {
super(Opcodes.ASM9);
throw new UnsupportedOperationException();
}
/**
* Creates a class writer.
*
* @param classReader A class reader of which to retain the constant pool, if possible.
* @param flags The ASM flags to consider.
* @param getSuperClass A resolver for the supplied internal class name's internal super class name. If
* a class is an interface, {@code null} should be returned. As a method to allow
* pre-Java 8 code to call this constructor via reflection.
* @param target The target to invoke the reflective method on.
*/
public JdkClassWriter(JdkClassReader classReader, int flags, Method getSuperClass, Object target) {
super(Opcodes.ASM9);
throw new UnsupportedOperationException();
}
/**
* Creates a class writer.
*
* @param flags The ASM flags to consider.
* @param getSuperClass A resolver for the supplied internal class name's internal super class name. If
* a class is an interface, {@code null} should be returned.
*/
public JdkClassWriter(int flags, Function getSuperClass) {
super(Opcodes.ASM9);
throw new UnsupportedOperationException();
}
/**
* Creates a class writer.
*
* @param classReader A class reader of which to retain the constant pool, if possible.
* @param flags The ASM flags to consider.
* @param getSuperClass A resolver for the supplied internal class name's internal super class name. If
* a class is an interface, {@code null} should be returned.
*/
public JdkClassWriter(JdkClassReader classReader, int flags, Function getSuperClass) {
super(Opcodes.ASM9);
throw new UnsupportedOperationException();
}
/**
* Returns the generated class file.
*
* @return The class file as a byte array.
*/
public byte[] toByteArray() {
throw new UnsupportedOperationException();
}
/**
* Returns the super class of the class that is provided by name. The default implementation
* resolves the super class from this instance's class' {@link ClassLoader}, unless
* {@link #getClassLoader()} is overridden.
*
* This is used for generating stack map frames.
*
* @param name The name of the class for which to resolve the super class.
* @return The name of the resolved super class.
*/
protected String getSuperClass(String name) {
throw new UnsupportedOperationException();
}
/**
* Returns the class loader to use for resolving the super class of a discovered class.
*
* @return The class loader to use for resolving a super class's name.
*/
protected ClassLoader getClassLoader() {
throw new UnsupportedOperationException();
}
@Override
public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
throw new UnsupportedOperationException();
}
@Override
public void visitSource(String source, String debug) {
throw new UnsupportedOperationException();
}
@Override
public ModuleVisitor visitModule(String name, int access, String version) {
throw new UnsupportedOperationException();
}
@Override
public void visitNestHost(String nestHost) {
throw new UnsupportedOperationException();
}
@Override
public void visitOuterClass(String owner, String name, String descriptor) {
throw new UnsupportedOperationException();
}
@Override
public AnnotationVisitor visitAnnotation(String descriptor, boolean visible) {
throw new UnsupportedOperationException();
}
@Override
public void visitAttribute(Attribute attribute) {
throw new UnsupportedOperationException();
}
@Override
public AnnotationVisitor visitTypeAnnotation(int typeRef, TypePath typePath, String descriptor, boolean visible) {
throw new UnsupportedOperationException();
}
@Override
public void visitNestMember(String nestMember) {
throw new UnsupportedOperationException();
}
@Override
public void visitPermittedSubclass(String permittedSubclass) {
throw new UnsupportedOperationException();
}
@Override
public void visitInnerClass(String name, String outerName, String innerName, int access) {
throw new UnsupportedOperationException();
}
@Override
public RecordComponentVisitor visitRecordComponent(String name, String descriptor, String signature) {
throw new UnsupportedOperationException();
}
@Override
public FieldVisitor visitField(int access, String name, String descriptor, String signature, Object value) {
throw new UnsupportedOperationException();
}
@Override
public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) {
throw new UnsupportedOperationException();
}
@Override
public void visitEnd() {
throw new UnsupportedOperationException();
}
}
asm-jdk-bridge-0.0.10/asm-jdk-bridge/src/main/java/codes/rafael/asmjdkbridge/ProbingClassReader.java0000664 0000000 0000000 00000013302 15023613512 0033112 0 ustar 00root root 0000000 0000000 package codes.rafael.asmjdkbridge;
import org.objectweb.asm.Attribute;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.ClassVisitor;
import org.objectweb.asm.ClassWriter;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
/**
* A class reader that automatically resolves a suitable reader, either based on ASM (if ASM officially
* supports a class file version) or a JDK Class File API based implementation.
*/
public class ProbingClassReader {
private final ProbingResolver resolver;
/**
* Creates a new class reader.
*
* @param classFile The class file to represent.
* @param attributePrototypes Prototypes of ASM attributes to map if discovered.
*/
public ProbingClassReader(byte[] classFile, Attribute... attributePrototypes) {
resolver = ProbingResolver.ofClassFile(classFile, attributePrototypes);
}
/**
* Creates a new class reader.
*
* @param inputStream An input stream of the class file to represent.
* @param attributePrototypes Prototypes of ASM attributes to map if discovered.
* @throws IOException If the stream cannot be read.
*/
public ProbingClassReader(InputStream inputStream, Attribute... attributePrototypes) throws IOException {
this(readAllBytes(inputStream), attributePrototypes);
}
/**
* Creates a new class reader.
*
* @param className The name of the class to represent. The class must be resolvable from the system loader.
* @param attributePrototypes Prototypes of ASM attributes to map if discovered.
* @throws IOException If the class file cannot be read.
*/
public ProbingClassReader(String className, Attribute... attributePrototypes) throws IOException {
byte[] classFile;
try (InputStream inputStream = ClassLoader.getSystemResourceAsStream(className.replace('.', '/') + ".class")) {
classFile = readAllBytes(inputStream);
}
resolver = ProbingResolver.ofClassFile(classFile, attributePrototypes);
}
private static byte[] readAllBytes(InputStream inputStream) throws IOException {
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
byte[] buffer = new byte[1024 * 8];
int length;
while ((length = inputStream.read(buffer)) != -1) {
outputStream.write(buffer, 0, length);
}
return outputStream.toByteArray();
}
/**
* Returns the access flags of this class as stored in the class file.
*
* @return The access flags of this class as stored in the class file.
*/
public int getAccess() {
return resolver.getAccess();
}
/**
* Returns the internal name of this class.
*
* @return The internal name of this class.
*/
public String getClassName() {
return resolver.getClassName();
}
/**
* Returns the internal super class name of this class or {@code null} for {@link Object}.
*
* @return The internal super class name of this class or {@code null} for {@link Object}.
*/
public String getSuperName() {
return resolver.getSuperName();
}
/**
* Returns the internal interface names of this class. Maybe {@code null}.
*
* @return The internal interface names of this class.
*/
public String[] getInterfaces() {
return resolver.getInterfaces();
}
/**
* Accepts a class visitor for the represented class file.
*
* @param classVisitor The class visitor to delegate calls to.
* @param flags The ASM flags to consider when visiting the class file.
*/
public void accept(ClassVisitor classVisitor, int flags) {
resolver.accept(classVisitor, flags);
}
/**
* Resolves the underlying class reader to an implementation-equivalent class writer. Using this approach,
* an attempt is made to retain the constant pool if a class is supposed to be transformed.
*
* @param flags The ASM flags to consider when creating the class writer.
* @return A suitable container for a class writer.
*/
public ClassWriterContainer toClassWriter(int flags) {
return resolver.toClassWriter(flags);
}
/**
* A container for a class writer.
*
* @param The type of the class visitor that represents the class writer.
*/
public abstract static class ClassWriterContainer {
final T delegate;
ClassWriterContainer(T delegate) {
this.delegate = delegate;
}
/**
* Returns the underlying ASM class visitor.
*
* @return The underlying ASM class visitor.
*/
public ClassVisitor getClassVisitor() {
return delegate;
}
/**
* Returns the byte array that is created by this class writer.
*
* @return A byte array that represents the generated class file.
*/
public abstract byte[] toByteArray();
static class OfAsm extends ClassWriterContainer {
OfAsm(ClassReader classReader, int flags) {
super(new ClassWriter(classReader, flags));
}
@Override
public byte[] toByteArray() {
return delegate.toByteArray();
}
}
static class OfJdk extends ClassWriterContainer {
OfJdk(JdkClassReader classReader, int flags) {
super(new JdkClassWriter(classReader, flags));
}
@Override
public byte[] toByteArray() {
return delegate.toByteArray();
}
}
}
}
asm-jdk-bridge-0.0.10/asm-jdk-bridge/src/main/java/codes/rafael/asmjdkbridge/ProbingClassWriter.java0000664 0000000 0000000 00000006267 15023613512 0033200 0 ustar 00root root 0000000 0000000 package codes.rafael.asmjdkbridge;
import org.objectweb.asm.ClassVisitor;
import org.objectweb.asm.ClassWriter;
import org.objectweb.asm.Opcodes;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.function.Function;
/**
* A class writer that automatically resolves a suitable writer, either based on ASM (if ASM officially
* supports a class file version) or a JDK Class File API based implementation.
*/
public class ProbingClassWriter extends ClassVisitor {
private final int flags;
private final Function getSuperClass;
/**
* Creates a class writer.
*
* @param flags The ASM flags to consider.
*/
public ProbingClassWriter(int flags) {
super(Opcodes.ASM9);
this.flags = flags;
getSuperClass = null;
}
/**
* Creates a class writer.
*
* @param flags The ASM flags to consider.
* @param getSuperClass A resolver for the supplied internal class name's internal super class name. If
* a class is an interface, {@code null} should be returned. As a method to allow
* pre-Java 8 code to call this constructor via reflection.
* @param target The target to invoke the reflective method on.
*/
public ProbingClassWriter(int flags, Method getSuperClass, Object target) {
super(Opcodes.ASM9);
this.flags = flags;
this.getSuperClass = getSuperClass == null ? null : name -> {
try {
return (String) getSuperClass.invoke(target, name);
} catch (IllegalAccessException | InvocationTargetException e) {
throw new RuntimeException(e);
}
};
}
/**
* Creates a class writer.
*
* @param flags The ASM flags to consider.
* @param getSuperClass A resolver for the supplied internal class name's internal super class name. If
* a class is an interface, {@code null} should be returned.
*/
public ProbingClassWriter(int flags, Function getSuperClass) {
super(Opcodes.ASM9);
this.flags = flags;
this.getSuperClass = getSuperClass;
}
@Override
public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
cv = ProbingResolver.ofVersion(flags, version, getSuperClass);
super.visit(version, access, name, signature, superName, interfaces);
}
/**
* Returns the generated class file.
*
* @return The class file as a byte array.
*/
public byte[] toByteArray() {
if (cv instanceof JdkClassWriter) {
return ((JdkClassWriter) cv).toByteArray();
} else if (cv instanceof ClassWriter) {
return ((ClassWriter) cv).toByteArray();
} else if (cv instanceof ProbingClassWriter) {
return ((ProbingClassWriter) cv).toByteArray();
} else if (cv == null) {
throw new IllegalStateException("No version discovered");
} else {
throw new IllegalStateException("Unexpected type: " + cv.getClass().getTypeName());
}
}
}
asm-jdk-bridge-0.0.10/asm-jdk-bridge/src/main/java/codes/rafael/asmjdkbridge/ProbingResolver.java 0000664 0000000 0000000 00000011704 15023613512 0032527 0 ustar 00root root 0000000 0000000 package codes.rafael.asmjdkbridge;
import org.objectweb.asm.Attribute;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.ClassVisitor;
import org.objectweb.asm.ClassWriter;
import org.objectweb.asm.Opcodes;
import java.util.function.Function;
abstract class ProbingResolver {
private static final String OBJECT = "java/lang/Object";
private static final int SUPPORTED;
static {
int version = Opcodes.V24;
try {
int candidate = 25;
while (!Thread.interrupted()) {
version = (Integer) Opcodes.class.getField("V" + candidate++).get(null);
}
} catch (Throwable ignored) {
}
SUPPORTED = version & 0xFFFF;
}
static ClassVisitor ofVersion(int flags, int version, Function getSuperClass) {
if (version > SUPPORTED) {
return new JdkClassWriter(flags, getSuperClass);
} else {
return new ClassWriter(flags) {
@Override
protected String getCommonSuperClass(String type1, String type2) {
if (getSuperClass == null) {
return super.getCommonSuperClass(type1, type2);
}
if (type1.equals(type2)) {
return type1;
}
String class1 = getSuperClass.apply(type1), class2 = getSuperClass.apply(type2);
if (class1 == null || class2 == null) {
return OBJECT;
} else {
while (!class1.equals(OBJECT)) {
if (class1.equals(type2)) {
return type2;
}
class1 = getSuperClass.apply(class1);
}
while (!class2.equals(OBJECT)) {
if (class2.equals(type1)) {
return type1;
}
class2 = getSuperClass.apply(class2);
}
return OBJECT;
}
}
};
}
}
static ProbingResolver ofClassFile(byte[] classFile, Attribute[] attributePrototypes) {
int majorVersion = classFile[6] << 8 | classFile[7];
if (majorVersion > SUPPORTED) {
return new OfJdk(classFile, attributePrototypes);
} else {
return new OfAsm(classFile, attributePrototypes);
}
}
abstract int getAccess();
abstract String getClassName();
abstract String getSuperName();
abstract String[] getInterfaces();
abstract void accept(ClassVisitor classVisitor, int flags);
abstract ProbingClassReader.ClassWriterContainer toClassWriter(int flags);
static class OfAsm extends ProbingResolver {
private final ClassReader classReader;
private final Attribute[] attributePrototypes;
OfAsm(byte[] classFile, Attribute[] attributePrototypes) {
classReader = new ClassReader(classFile);
this.attributePrototypes = attributePrototypes;
}
@Override
int getAccess() {
return classReader.getAccess();
}
@Override
String getClassName() {
return classReader.getClassName();
}
@Override
String getSuperName() {
return classReader.getSuperName();
}
@Override
String[] getInterfaces() {
return classReader.getInterfaces();
}
@Override
void accept(ClassVisitor classVisitor, int flags) {
classReader.accept(classVisitor, attributePrototypes, flags);
}
@Override
ProbingClassReader.ClassWriterContainer toClassWriter(int flags) {
return new ProbingClassReader.ClassWriterContainer.OfAsm(classReader, flags);
}
}
static class OfJdk extends ProbingResolver {
private final JdkClassReader classReader;
OfJdk(byte[] classFile, Attribute[] attributePrototypes) {
classReader = new JdkClassReader(classFile, attributePrototypes);
}
@Override
int getAccess() {
return classReader.getAccess();
}
@Override
String getClassName() {
return classReader.getClassName();
}
@Override
String getSuperName() {
return classReader.getSuperName();
}
@Override
String[] getInterfaces() {
return classReader.getInterfaces();
}
@Override
void accept(ClassVisitor classVisitor, int flags) {
classReader.accept(classVisitor, flags);
}
@Override
ProbingClassReader.ClassWriterContainer toClassWriter(int flags) {
return new ProbingClassReader.ClassWriterContainer.OfJdk(classReader, flags);
}
}
}
asm-jdk-bridge-0.0.10/pom.xml 0000664 0000000 0000000 00000006630 15023613512 0015670 0 ustar 00root root 0000000 0000000
4.0.0
codes.rafael.asmjdkbridge
asm-jdk-bridge-parent
0.0.10
pom
ASM to OpenJDK Class API bridge (parent)
A common parent for the ASM to OpenJDK Class File API.
2025
asm-jdk-bridge
asm-jdk-bridge-test
https://github.com/raphw/asm-jdk-bridge
8
UTF-8
The Apache Software License, Version 2.0
https://www.apache.org/licenses/LICENSE-2.0.txt
repo
A business-friendly OSS license
raphw
Rafael Winterhalter
rafael.wth@gmail.com
https://rafael.codes
developer
+1
org.sonatype.oss
oss-parent
9
github.com
https://github.com/raphw/asm-jdk-bridge/issues
scm:git:git@github.com:raphw/asm-jdk-bridge.git
scm:git:git@github.com:raphw/asm-jdk-bridge.git
git@github.com:raphw/asm-jdk-bridge.git
HEAD
org.apache.maven.plugins
maven-javadoc-plugin
3.10.1
org.apache.maven.plugins
maven-gpg-plugin
3.2.4
sign-artifacts
install
sign
org.sonatype.central
central-publishing-maven-plugin
0.7.0
true
true
central