@Override public ClassHolder map(String name) { for (Transformation transformation : transformations) { if (name.startsWith(transformation.packageName)) { int index = name.lastIndexOf('.'); String className = name.substring(index + 1); String packageName = index > 0 ? name.substring(0, index) : ""; ClassHolder classHolder = innerMapper.map(transformation.packagePrefix + packageName + "." + transformation.classPrefix + className); if (classHolder != null) { classHolder = renamer.rename(classHolder); } return classHolder; } } return innerMapper.map(name); }
@Override public void visit(ConstructArrayInstruction insn) { insn.setItemType(rename(insn.getItemType())); }
private void rename(AnnotationContainer source, AnnotationContainer target) { for (AnnotationHolder annot : source.all()) { if (!annot.getType().equals(Rename.class.getName()) && !annot.getType().equals(Superclass.class.getName())) { target.add(rename(annot)); } } }
@Override public void visit(ConstructMultiArrayInstruction insn) { insn.setItemType(rename(insn.getItemType())); }
@Override public void visit(CastInstruction insn) { insn.setTargetType(rename(insn.getTargetType())); }
@Override public void visit(ClassConstantInstruction insn) { insn.setConstant(rename(insn.getConstant())); }
@Override public void visit(IsInstanceInstruction insn) { insn.setType(rename(insn.getType())); }
private RuntimeConstant rename(RuntimeConstant cst) { switch (cst.getKind()) { case RuntimeConstant.TYPE: return new RuntimeConstant(rename(cst.getValueType())); case RuntimeConstant.METHOD: return new RuntimeConstant(rename(cst.getMethodType())); case RuntimeConstant.METHOD_HANDLE: return new RuntimeConstant(rename(cst.getMethodHandle())); default: return cst; } }
@Override public void visit(InvokeDynamicInstruction insn) { ValueType[] signature = insn.getMethod().getSignature(); for (int i = 0; i < signature.length; ++i) { signature[i] = rename(signature[i]); } insn.setMethod(new MethodDescriptor(insn.getMethod().getName(), signature)); for (int i = 0; i < insn.getBootstrapArguments().size(); ++i) { insn.getBootstrapArguments().set(i, rename(insn.getBootstrapArguments().get(i))); } }
public MethodHolder rename(MethodHolder method) { String methodName = method.getName(); AnnotationHolder renameAnnot = method.getAnnotations().get(Rename.class.getName()); if (renameAnnot != null) { methodName = renameAnnot.getValues().get("value").getString(); } ValueType[] signature = method.getSignature(); for (int i = 0; i < signature.length; ++i) { signature[i] = rename(signature[i]); } MethodHolder renamedMethod = new MethodHolder(methodName, signature); renamedMethod.getModifiers().addAll(method.getModifiers()); renamedMethod.setLevel(method.getLevel()); renamedMethod.setProgram(method.getProgram()); rename(method.getAnnotations(), renamedMethod.getAnnotations()); rename(renamedMethod.getProgram()); return renamedMethod; }
public FieldHolder rename(FieldHolder field) { FieldHolder renamedField = new FieldHolder(field.getName()); renamedField.getModifiers().addAll(field.getModifiers()); renamedField.setLevel(field.getLevel()); renamedField.setType(rename(field.getType())); renamedField.setInitialValue(field.getInitialValue()); rename(field.getAnnotations(), renamedField.getAnnotations()); return renamedField; }
private ValueType rename(ValueType type) { if (type instanceof ValueType.Array) { ValueType itemType = ((ValueType.Array) type).getItemType(); return referenceCache.getCached(ValueType.arrayOf(rename(itemType))); } else if (type instanceof ValueType.Object) { String className = ((ValueType.Object) type).getClassName(); return referenceCache.getCached(ValueType.object(classNameMapper.map(className))); } else { return type; } }
case GET_FIELD: return MethodHandle.fieldGetter(classNameMapper.map(handle.getClassName()), handle.getName(), rename(handle.getValueType())); case GET_STATIC_FIELD: return MethodHandle.staticFieldGetter(classNameMapper.map(handle.getClassName()), handle.getName(), rename(handle.getValueType())); case PUT_FIELD: return MethodHandle.fieldSetter(classNameMapper.map(handle.getClassName()), handle.getName(), rename(handle.getValueType())); case PUT_STATIC_FIELD: return MethodHandle.staticFieldSetter(classNameMapper.map(handle.getClassName()), handle.getName(), rename(handle.getValueType())); case INVOKE_VIRTUAL: return MethodHandle.virtualCaller(classNameMapper.map(handle.getClassName()), handle.getName(), rename(handle.signature())); case INVOKE_STATIC: return MethodHandle.staticCaller(classNameMapper.map(handle.getClassName()), handle.getName(), rename(handle.signature())); case INVOKE_SPECIAL: return MethodHandle.specialCaller(classNameMapper.map(handle.getClassName()), handle.getName(), rename(handle.signature())); case INVOKE_CONSTRUCTOR: return MethodHandle.constructorCaller(classNameMapper.map(handle.getClassName()), handle.getName(), rename(handle.signature())); case INVOKE_INTERFACE: return MethodHandle.interfaceCaller(classNameMapper.map(handle.getClassName()), handle.getName(), rename(handle.signature())); default: break;
@Override public void visit(InvokeInstruction insn) { String className = classNameMapper.map(insn.getMethod().getClassName()); ValueType[] signature = insn.getMethod().getSignature(); boolean changed = true; for (int i = 0; i < signature.length; ++i) { ValueType type = signature[i]; ValueType newType = rename(type); if (newType != null) { changed = true; } signature[i] = newType; } if (changed) { insn.setMethod(referenceCache.getCached(new MethodReference(className, new MethodDescriptor(insn.getMethod().getName(), signature)))); } }
private void rename(AnnotationContainer source, AnnotationContainer target) { for (AnnotationHolder annot : source.all()) { if (!annot.getType().equals(Rename.class.getName()) && !annot.getType().equals(Superclass.class.getName())) { target.add(rename(annot)); } } }
@Override public void visit(ConstructArrayInstruction insn) { insn.setItemType(rename(insn.getItemType())); }
@Override public void visit(ConstructMultiArrayInstruction insn) { insn.setItemType(rename(insn.getItemType())); }
@Override public void visit(InvokeDynamicInstruction insn) { ValueType[] signature = insn.getMethod().getSignature(); for (int i = 0; i < signature.length; ++i) { signature[i] = rename(signature[i]); } insn.setMethod(new MethodDescriptor(insn.getMethod().getName(), signature)); for (int i = 0; i < insn.getBootstrapArguments().size(); ++i) { insn.getBootstrapArguments().set(i, rename(insn.getBootstrapArguments().get(i))); } }
private ValueType rename(ValueType type) { if (type instanceof ValueType.Array) { ValueType itemType = ((ValueType.Array) type).getItemType(); return ValueType.arrayOf(rename(itemType)); } else if (type instanceof ValueType.Object) { String className = ((ValueType.Object) type).getClassName(); return ValueType.object(classNameMapper.map(className)); } else { return type; } }