private void finalizeToString(MethodVisitor mv) {
// The StringBuilder is on the top of the stack from the last append() -
// duplicate it for call to replace()
mv.visitVarInsn(ALOAD, 1);
mv.visitInsn(DUP);
// The replace starts at 2 characters before the end, to remove the
// extra command and space added
mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/StringBuilder", "length", "()I", false);
mv.visitLdcInsn(2);
mv.visitInsn(ISUB);
mv.visitVarInsn(ALOAD, 1);
mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/StringBuilder", "length", "()I", false);
mv.visitLdcInsn("}");
mv.visitMethodInsn(
INVOKEVIRTUAL,
"java/lang/StringBuilder",
"replace",
"(IILjava/lang/String;)Ljava/lang/StringBuilder;",
false);
mv.visitMethodInsn(
INVOKEVIRTUAL, "java/lang/StringBuilder", "toString", "()Ljava/lang/String;", false);
mv.visitInsn(ARETURN);
mv.visitMaxs(0, 0);
mv.visitEnd();
}
private void contributeToString(
String internalName, Property<Class<?>, Method> property, MethodVisitor toStringMv) {
if (property.isLeastSpecificType()) {
Type returnType = Type.getReturnType(property.getAccessor());
toStringMv.visitVarInsn(ALOAD, 0);
toStringMv.visitVarInsn(ALOAD, 1);
toStringMv.visitLdcInsn(property.getName());
toStringMv.visitMethodInsn(
INVOKEVIRTUAL,
"java/lang/StringBuilder",
"append",
"(Ljava/lang/Object;)Ljava/lang/StringBuilder;",
false);
toStringMv.visitLdcInsn("=");
toStringMv.visitMethodInsn(
INVOKEVIRTUAL,
"java/lang/StringBuilder",
"append",
"(Ljava/lang/Object;)Ljava/lang/StringBuilder;",
false);
toStringMv.visitVarInsn(ALOAD, 0);
toStringMv.visitMethodInsn(
INVOKESPECIAL,
internalName,
property.getAccessor().getName(),
Type.getMethodDescriptor(property.getAccessor()),
false);
String desc =
property.getType().isPrimitive()
? Type.getDescriptor(property.getType())
: "Ljava/lang/Object;";
toStringMv.visitMethodInsn(
INVOKEVIRTUAL,
"java/lang/StringBuilder",
"append",
"(" + desc + ")Ljava/lang/StringBuilder;",
false);
toStringMv.visitLdcInsn(", ");
toStringMv.visitMethodInsn(
INVOKEVIRTUAL,
"java/lang/StringBuilder",
"append",
"(Ljava/lang/Object;)Ljava/lang/StringBuilder;",
false);
}
}
void compile(MethodVisitor mv) {
// compiles e1, e2, and adds the instructions to compare the two values
e1.compile(mv);
e2.compile(mv);
Label iftrue = new Label();
Label end = new Label();
mv.visitJumpInsn(IF_ICMPGT, iftrue);
// case where e1 <= e2 : pushes false and jump to "end"
mv.visitLdcInsn(new Integer(0));
mv.visitJumpInsn(GOTO, end);
// case where e1 > e2 : pushes true
mv.visitLabel(iftrue);
mv.visitLdcInsn(new Integer(1));
mv.visitLabel(end);
}
public static void pushConstant(MethodVisitor mv, int value) {
switch (value) {
case 0:
mv.visitInsn(ICONST_0);
break;
case 1:
mv.visitInsn(ICONST_1);
break;
case 2:
mv.visitInsn(ICONST_2);
break;
case 3:
mv.visitInsn(ICONST_3);
break;
case 4:
mv.visitInsn(ICONST_4);
break;
case 5:
mv.visitInsn(ICONST_5);
break;
default:
if (value >= Byte.MIN_VALUE && value <= Byte.MAX_VALUE) {
mv.visitIntInsn(BIPUSH, value);
} else if (value >= Short.MIN_VALUE && value <= Short.MAX_VALUE) {
mv.visitIntInsn(SIPUSH, value);
} else {
mv.visitLdcInsn(Integer.valueOf(value));
}
}
}
private void writeMapDotProperty(
final Expression receiver,
final String methodName,
final MethodVisitor mv,
final boolean safe) {
receiver.visit(controller.getAcg()); // load receiver
Label exit = new Label();
if (safe) {
Label doGet = new Label();
mv.visitJumpInsn(IFNONNULL, doGet);
controller.getOperandStack().remove(1);
mv.visitInsn(ACONST_NULL);
mv.visitJumpInsn(GOTO, exit);
mv.visitLabel(doGet);
receiver.visit(controller.getAcg());
}
mv.visitLdcInsn(methodName); // load property name
mv.visitMethodInsn(
INVOKEINTERFACE, "java/util/Map", "get", "(Ljava/lang/Object;)Ljava/lang/Object;", true);
if (safe) {
mv.visitLabel(exit);
}
controller.getOperandStack().replace(OBJECT_TYPE);
}
private void createAddMessage(ClassNode cn) {
Pattern p =
new PatternBuilder()
.add(
new InstructionElement(ALOAD),
new LdcElement(new LdcInsnNode("")),
new InstructionElement(ALOAD),
new InstructionElement(INVOKEVIRTUAL))
.build();
MethodInsnNode ebola1 = null;
for (MethodNode mn : cn.methods) {
if (!p.contains(mn.instructions)) continue;
int offset = p.getOffset(mn.instructions);
ebola1 = (MethodInsnNode) mn.instructions.get(offset + 3);
}
{
MethodVisitor mv =
cn.visitMethod(ACC_PUBLIC, "addChatMessage", "(Ljava/lang/String;)V", null, null);
mv.visitVarInsn(ALOAD, 0);
mv.visitLdcInsn("");
mv.visitVarInsn(ALOAD, 1);
mv.visitMethodInsn(INVOKEVIRTUAL, ebola1.owner, ebola1.name, ebola1.desc, ebola1.itf);
mv.visitInsn(RETURN);
mv.visitEnd();
}
}
/**
* Initializes a static mixin field.
*
* @param mv
* @param fieldInfo
*/
private void initializeStaticMixinField(final MethodVisitor mv, final MixinFieldInfo fieldInfo) {
mv.visitLdcInsn(fieldInfo.mixinClassInfo.getName().replace('/', '.'));
if (fieldInfo.isPerJVM) {
mv.visitFieldInsn(
GETSTATIC, m_declaringTypeName, TARGET_CLASS_FIELD_NAME, CLASS_CLASS_SIGNATURE);
mv.visitMethodInsn(
INVOKEVIRTUAL,
CLASS_CLASS,
GETCLASSLOADER_METHOD_NAME,
CLASS_CLASS_GETCLASSLOADER_METHOD_SIGNATURE);
mv.visitMethodInsn(
INVOKESTATIC, MIXINS_CLASS_NAME, MIXIN_OF_METHOD_NAME, MIXIN_OF_METHOD_PER_JVM_SIGNATURE);
} else {
mv.visitFieldInsn(
GETSTATIC, m_declaringTypeName, TARGET_CLASS_FIELD_NAME, CLASS_CLASS_SIGNATURE);
mv.visitMethodInsn(
INVOKESTATIC,
MIXINS_CLASS_NAME,
MIXIN_OF_METHOD_NAME,
MIXIN_OF_METHOD_PER_CLASS_SIGNATURE);
}
mv.visitTypeInsn(CHECKCAST, fieldInfo.mixinClassInfo.getName().replace('.', '/'));
mv.visitFieldInsn(
PUTSTATIC,
m_declaringTypeName,
fieldInfo.fieldName,
fieldInfo.mixinClassInfo.getSignature());
}
@Test
public void testInstrumentationLegacyClassOtherType() throws Exception {
ClassVisitor classVisitor =
TypeConstantAdjustment.INSTANCE.wrap(
mock(TypeDescription.class),
this.classVisitor,
mock(Implementation.Context.class),
mock(TypePool.class),
new FieldList.Empty<FieldDescription.InDefinedShape>(),
new MethodList.Empty<MethodDescription>(),
IGNORED,
IGNORED);
classVisitor.visit(
ClassFileVersion.JAVA_V4.getMinorMajorVersion(), FOOBAR, FOO, BAR, QUX, new String[] {BAZ});
MethodVisitor methodVisitor =
classVisitor.visitMethod(FOOBAR, FOO, BAR, QUX, new String[] {BAZ});
assertThat(methodVisitor, not(this.methodVisitor));
methodVisitor.visitLdcInsn(FOO);
verify(this.classVisitor)
.visit(
ClassFileVersion.JAVA_V4.getMinorMajorVersion(),
FOOBAR,
FOO,
BAR,
QUX,
new String[] {BAZ});
verify(this.classVisitor).visitMethod(FOOBAR, FOO, BAR, QUX, new String[] {BAZ});
verifyNoMoreInteractions(this.classVisitor);
verify(this.methodVisitor).visitLdcInsn(FOO);
verifyNoMoreInteractions(this.methodVisitor);
}
@Override
public void visitLdcInsn(final Object cst) {
checkStartCode();
checkEndCode();
checkLDCConstant(cst);
super.visitLdcInsn(cst);
++insnCount;
}
public static byte[] dump1() {
ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
FieldVisitor fv;
MethodVisitor mv;
cw.visit(V1_4, ACC_SUPER, "pkg/Outer$1", null, "pkg/Outer", null);
cw.visitOuterClass("pkg/Outer", "m", "()V");
cw.visitInnerClass("pkg/Outer$1", null, null, 0);
fv = cw.visitField(ACC_FINAL + ACC_SYNTHETIC, "this$0", "Lpkg/Outer;", null, null);
fv.visitEnd();
mv = cw.visitMethod(0, "<init>", "(Lpkg/Outer;)V", null, null);
mv.visitCode();
mv.visitVarInsn(ALOAD, 0);
mv.visitVarInsn(ALOAD, 1);
mv.visitFieldInsn(PUTFIELD, "pkg/Outer$1", "this$0", "Lpkg/Outer;");
mv.visitVarInsn(ALOAD, 0);
mv.visitMethodInsn(INVOKESPECIAL, "pkg/Outer", "<init>", "()V");
mv.visitInsn(RETURN);
mv.visitMaxs(0, 0);
mv.visitEnd();
mv = cw.visitMethod(ACC_PUBLIC, "toString", "()Ljava/lang/String;", null, null);
mv.visitCode();
mv.visitTypeInsn(NEW, "java/lang/StringBuilder");
mv.visitInsn(DUP);
mv.visitMethodInsn(INVOKESPECIAL, "java/lang/StringBuilder", "<init>", "()V");
mv.visitVarInsn(ALOAD, 0);
mv.visitFieldInsn(GETFIELD, "pkg/Outer$1", "this$0", "Lpkg/Outer;");
mv.visitMethodInsn(
INVOKEVIRTUAL,
"java/lang/StringBuilder",
"append",
"(Ljava/lang/Object;)Ljava/lang/StringBuilder;");
mv.visitLdcInsn(" ");
mv.visitMethodInsn(
INVOKEVIRTUAL,
"java/lang/StringBuilder",
"append",
"(Ljava/lang/String;)Ljava/lang/StringBuilder;");
mv.visitVarInsn(ALOAD, 0);
mv.visitFieldInsn(GETFIELD, "pkg/Outer$1", "this$0", "Lpkg/Outer;");
mv.visitMethodInsn(INVOKESTATIC, "pkg/Outer", "access$000", "(Lpkg/Outer;)I");
mv.visitMethodInsn(
INVOKEVIRTUAL, "java/lang/StringBuilder", "append", "(I)Ljava/lang/StringBuilder;");
mv.visitMethodInsn(
INVOKEVIRTUAL, "java/lang/StringBuilder", "toString", "()Ljava/lang/String;");
mv.visitInsn(ARETURN);
mv.visitMaxs(0, 0);
mv.visitEnd();
cw.visitEnd();
return cw.toByteArray();
}
private void loadInitValue(ClassNode type) {
MethodVisitor mv = controller.getMethodVisitor();
if (ClassHelper.isPrimitiveType(type)) {
mv.visitLdcInsn(0);
} else {
mv.visitInsn(ACONST_NULL);
}
controller.getOperandStack().push(type);
}
@Override
protected void insertCauseCall(MethodVisitor mv, Parameter param, Class<?> targetType) {
mv.visitLdcInsn(Type.getType(this.anno.value()));
mv.visitMethodInsn(
INVOKEVIRTUAL,
Type.getInternalName(Cause.class),
"after",
"(Ljava/lang/Class;)Ljava/util/Optional;",
false);
}
private void setCanCallSettersField(
MethodVisitor methodVisitor, Type generatedType, boolean canCallSetters) {
putThisOnStack(methodVisitor);
methodVisitor.visitLdcInsn(canCallSetters);
methodVisitor.visitFieldInsn(
PUTFIELD,
generatedType.getInternalName(),
CAN_CALL_SETTERS_FIELD_NAME,
Type.BOOLEAN_TYPE.getDescriptor());
}
protected static void injectGetTargetClass(ClassWriter classWriter, Class<?> targetClass) {
MethodVisitor methodVisitor =
classWriter.visitMethod(
ACC_PUBLIC, "getTargetClass", "()Ljava/lang/Class;", "()Ljava/lang/Class<*>;", null);
methodVisitor.visitCode();
methodVisitor.visitLdcInsn(Type.getType(targetClass));
methodVisitor.visitInsn(ARETURN);
methodVisitor.visitMaxs(1, 1);
methodVisitor.visitEnd();
}
/**
* Creates bytecode for evaluating the argument values as integers. The bytecode is generated
* using the specified method visitor.
*
* @param visitor the method visitor
*/
private void compileInt(MethodVisitor visitor) {
Label labelFalse = new Label();
Label labelEnd = new Label();
value1.compile(visitor, Type.INT);
value2.compile(visitor, Type.INT);
visitor.visitJumpInsn(Opcodes.IF_ICMPLE, labelFalse);
// True
visitor.visitLdcInsn(true);
visitor.visitJumpInsn(Opcodes.GOTO, labelEnd);
// False
visitor.visitLabel(labelFalse);
visitor.visitLdcInsn(false);
visitor.visitLabel(labelEnd);
}
/**
* Creates bytecode for evaluating the argument values as doubles. The bytecode is generated using
* the specified method visitor.
*
* @param visitor the method visitor
*/
private void compileDouble(MethodVisitor visitor) {
Label labelFalse = new Label();
Label labelEnd = new Label();
value1.compile(visitor, Type.DOUBLE);
value2.compile(visitor, Type.DOUBLE);
visitor.visitInsn(Opcodes.DCMPL);
visitor.visitJumpInsn(Opcodes.IFLE, labelFalse);
// True
visitor.visitLdcInsn(true);
visitor.visitJumpInsn(Opcodes.GOTO, labelEnd);
// False
visitor.visitLabel(labelFalse);
visitor.visitLdcInsn(false);
visitor.visitLabel(labelEnd);
}
/** Generates the bytecode that pushes the given value onto the stack */
public void pushDouble(double aValue) {
if (aValue == 0) {
itsVisitor.visitInsn(Opcodes.DCONST_0);
return;
} else if (aValue == 1) {
itsVisitor.visitInsn(Opcodes.DCONST_1);
return;
}
itsVisitor.visitLdcInsn(new Double(aValue));
}
/** Generates the bytecode that pushes the given value onto the stack */
public void pushLong(long aValue) {
if (aValue == 0) {
itsVisitor.visitInsn(Opcodes.LCONST_0);
return;
} else if (aValue == 1) {
itsVisitor.visitInsn(Opcodes.LCONST_1);
return;
}
itsVisitor.visitLdcInsn(new Long(aValue));
}
private void writeManagedTypeStaticField(
Type generatedType, Class<?> managedTypeClass, MethodVisitor constructorVisitor) {
constructorVisitor.visitLdcInsn(Type.getType(managedTypeClass));
constructorVisitor.visitMethodInsn(
INVOKESTATIC, MODELTYPE_INTERNAL_NAME, "of", MODELTYPE_OF_METHOD_DESCRIPTOR, false);
constructorVisitor.visitFieldInsn(
PUTSTATIC,
generatedType.getInternalName(),
MANAGED_TYPE_FIELD_NAME,
Type.getDescriptor(ModelType.class));
}
/**
* Visits a class literal. If the type of the classnode is a primitive type, the generated
* bytecode will be a GETSTATIC Integer.TYPE. If the classnode is not a primitive type, we will
* generate a LDC instruction.
*/
public static void visitClassLiteral(MethodVisitor mv, ClassNode classNode) {
if (ClassHelper.isPrimitiveType(classNode)) {
mv.visitFieldInsn(
GETSTATIC,
getClassInternalName(ClassHelper.getWrapper(classNode)),
"TYPE",
"Ljava/lang/Class;");
} else {
mv.visitLdcInsn(org.objectweb.asm.Type.getType(getTypeDescription(classNode)));
}
}
public MethodVisitor visitMethod(
final int access,
final String methodName,
final String desc,
final String signature,
final String[] exceptions) {
if ("display2".equals(methodName)) {
return null; // 我们屏蔽了这个方法
}
if ("display1".equals(methodName)) {
MethodVisitor methodVisitor = cv.visitMethod(access, methodName, desc, signature, exceptions);
methodVisitor.visitCode();
// 增加的语句等价于增加代码：name = "我是name"
methodVisitor.visitVarInsn(
Opcodes.ALOAD, 0); // aload_0 is supposed to push 'this' on to the stack
methodVisitor.visitLdcInsn("我是name");
methodVisitor.visitFieldInsn(
Opcodes.PUTFIELD, "chapter03/asm/ForASMTestClass", "name", "Ljava/lang/String;");
// 这条语句等价于增加代码：value = "我是value";
methodVisitor.visitVarInsn(
Opcodes.ALOAD, 0); // aload_0 is supposed to push 'this' on to the stack
methodVisitor.visitLdcInsn("我是value");
methodVisitor.visitFieldInsn(
Opcodes.PUTFIELD, "chapter03/asm/ForASMTestClass", "value", "Ljava/lang/String;");
// 再将一个属性获取出来打印出来
methodVisitor.visitFieldInsn(
Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
methodVisitor.visitVarInsn(Opcodes.ALOAD, 0);
methodVisitor.visitFieldInsn(
Opcodes.GETFIELD, "chapter03/asm/ForASMTestClass", "name", "Ljava/lang/String;");
methodVisitor.visitMethodInsn(
Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V");
methodVisitor.visitEnd();
return methodVisitor; // 返回visitor
} else {
return cv.visitMethod(access, methodName, desc, signature, exceptions);
}
}
/** load the constant on the operand stack. */
public void pushConstant(ConstantExpression expression) {
MethodVisitor mv = controller.getMethodVisitor();
Object value = expression.getValue();
ClassNode origType = expression.getType().redirect();
ClassNode type = ClassHelper.getUnwrapper(origType);
boolean boxing = origType != type;
boolean asPrimitive = boxing || ClassHelper.isPrimitiveType(type);
if (value == null) {
mv.visitInsn(ACONST_NULL);
} else if (boxing && value instanceof Boolean) {
// special path for boxed boolean
Boolean bool = (Boolean) value;
String text = bool ? "TRUE" : "FALSE";
mv.visitFieldInsn(GETSTATIC, "java/lang/Boolean", text, "Ljava/lang/Boolean;");
boxing = false;
type = origType;
} else if (asPrimitive) {
pushPrimitiveConstant(mv, value, type);
} else if (value instanceof BigDecimal) {
String className = BytecodeHelper.getClassInternalName(value.getClass().getName());
mv.visitTypeInsn(NEW, className);
mv.visitInsn(DUP);
mv.visitLdcInsn(value.toString());
mv.visitMethodInsn(INVOKESPECIAL, className, "<init>", "(Ljava/lang/String;)V", false);
} else if (value instanceof BigInteger) {
String className = BytecodeHelper.getClassInternalName(value.getClass().getName());
mv.visitTypeInsn(NEW, className);
mv.visitInsn(DUP);
mv.visitLdcInsn(value.toString());
mv.visitMethodInsn(INVOKESPECIAL, className, "<init>", "(Ljava/lang/String;)V", false);
} else if (value instanceof String) {
mv.visitLdcInsn(value);
} else {
throw new ClassGeneratorException(
"Cannot generate bytecode for constant: " + value + " of type: " + type.getName());
}
push(type);
if (boxing) box();
}
@Override
public Object visitIntLitExpression(IntLitExpression intLitExpression, Object arg)
throws Exception {
MethodVisitor mv = ((InheritedAttributes) arg).mv; // this should be the
// first statement
// of all visit
// methods that
// generate
// instructions
mv.visitLdcInsn(intLitExpression.value);
return intType;
}
/** Generate a call to the delegate object. */
protected MethodVisitor makeDelegateCall(
final String name,
final String desc,
final String signature,
final String[] exceptions,
final int accessFlags) {
MethodVisitor mv = super.visitMethod(accessFlags, name, desc, signature, exceptions);
mv.visitVarInsn(ALOAD, 0); // load this
mv.visitFieldInsn(
GETFIELD,
proxyName,
DELEGATE_OBJECT_FIELD,
BytecodeHelper.getTypeDescription(delegateClass)); // load delegate
// using InvokerHelper to allow potential intercepted calls
int size;
mv.visitLdcInsn(name); // method name
Type[] args = Type.getArgumentTypes(desc);
BytecodeHelper.pushConstant(mv, args.length);
mv.visitTypeInsn(ANEWARRAY, "java/lang/Object");
size = 3;
int idx = 1;
for (int i = 0; i < args.length; i++) {
Type arg = args[i];
mv.visitInsn(DUP);
BytecodeHelper.pushConstant(mv, i);
// primitive types must be boxed
if (isPrimitive(arg)) {
mv.visitIntInsn(getLoadInsn(arg), idx);
String wrappedType = getWrappedClassDescriptor(arg);
mv.visitMethodInsn(
INVOKESTATIC,
wrappedType,
"valueOf",
"(" + arg.getDescriptor() + ")L" + wrappedType + ";");
} else {
mv.visitVarInsn(ALOAD, idx); // load argument i
}
size = Math.max(6, 5 + registerLen(arg));
idx += registerLen(arg);
mv.visitInsn(AASTORE); // store value into array
}
mv.visitMethodInsn(
INVOKESTATIC,
"org/codehaus/groovy/runtime/InvokerHelper",
"invokeMethod",
"(Ljava/lang/Object;Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/Object;");
unwrapResult(mv, desc);
mv.visitMaxs(size, registerLen(args) + 1);
return EMPTY_VISITOR;
}
// the overload of type Object for Groovy coercions: public void setFoo(Object foo)
private void createTypeConvertingSetter(
ClassVisitor visitor, Type generatedType, ModelProperty<?> property) {
if (!property.isWritable() || !(property.getSchema() instanceof ScalarValueSchema)) {
return;
}
Class<?> propertyClass = property.getType().getConcreteClass();
Type propertyType = Type.getType(propertyClass);
Class<?> boxedClass =
propertyClass.isPrimitive() ? BOXED_TYPES.get(propertyClass) : propertyClass;
Type boxedType = Type.getType(boxedClass);
Method setter = property.getSetter().getMethod();
MethodVisitor methodVisitor =
declareMethod(
visitor,
setter.getName(),
SET_OBJECT_PROPERTY_DESCRIPTOR,
SET_OBJECT_PROPERTY_DESCRIPTOR);
putThisOnStack(methodVisitor);
putTypeConverterFieldValueOnStack(methodVisitor, generatedType);
// Object converted = $typeConverter.convert(foo, Float.class, false);
methodVisitor.visitVarInsn(ALOAD, 1); // put var #1 ('foo') on the stack
methodVisitor.visitLdcInsn(boxedType); // push the constant Class onto the stack
methodVisitor.visitInsn(
propertyClass.isPrimitive()
? ICONST_1
: ICONST_0); // push int 1 or 0 (interpreted as true or false) onto the stack
methodVisitor.visitMethodInsn(
INVOKEINTERFACE,
TYPE_CONVERTER_TYPE.getInternalName(),
"convert",
COERCE_TO_SCALAR_DESCRIPTOR,
true);
methodVisitor.visitTypeInsn(CHECKCAST, boxedType.getInternalName());
if (propertyClass.isPrimitive()) {
unboxType(methodVisitor, propertyClass);
}
// invoke the typed setter, popping 'this' and 'converted' from the stack
methodVisitor.visitMethodInsn(
INVOKEVIRTUAL,
generatedType.getInternalName(),
setter.getName(),
Type.getMethodDescriptor(Type.VOID_TYPE, propertyType),
false);
finishVisitingMethod(methodVisitor);
}
@Override
public Object visitStringLitExpression(StringLitExpression stringLitExpression, Object arg)
throws Exception {
// throw new UnsupportedOperationException("code generation not yet implemented");
MethodVisitor mv = ((InheritedAttributes) arg).mv; // this should be the
// first statement
// of all visit
// methods that
// generate
// instructions
mv.visitLdcInsn(stringLitExpression.value);
return stringType;
}
/** Generates the bytecode that pushes the given value onto the stack */
public void pushFloat(float aValue) {
if (aValue == 0) {
itsVisitor.visitInsn(Opcodes.FCONST_0);
return;
} else if (aValue == 1) {
itsVisitor.visitInsn(Opcodes.FCONST_1);
return;
} else if (aValue == 2) {
itsVisitor.visitInsn(Opcodes.FCONST_2);
return;
}
itsVisitor.visitLdcInsn(new Float(aValue));
}
public void visitConstructor(ConstructorNode node) {
visitParameters(node, node.getParameters());
String methodType =
BytecodeHelper.getMethodDescriptor(ClassHelper.VOID_TYPE, node.getParameters());
mv = cv.visitMethod(node.getModifiers(), "<init>", methodType, null, null);
mv.visitTypeInsn(NEW, "java/lang/RuntimeException");
mv.visitInsn(DUP);
mv.visitLdcInsn("not intended for execution");
mv.visitMethodInsn(
INVOKESPECIAL, "java/lang/RuntimeException", "<init>", "(Ljava/lang/String;)V", false);
mv.visitInsn(ATHROW);
mv.visitMaxs(0, 0);
}
/**
* Initializes a member mixin field.
*
* @param mv
* @param fieldInfo
*/
private void initializeMemberMixinField(final MethodVisitor mv, final MixinFieldInfo fieldInfo) {
mv.visitVarInsn(ALOAD, 0);
mv.visitLdcInsn(fieldInfo.mixinClassInfo.getName().replace('/', '.'));
mv.visitVarInsn(ALOAD, 0);
mv.visitMethodInsn(
INVOKESTATIC,
MIXINS_CLASS_NAME,
MIXIN_OF_METHOD_NAME,
MIXIN_OF_METHOD_PER_INSTANCE_SIGNATURE);
mv.visitTypeInsn(CHECKCAST, fieldInfo.mixinClassInfo.getName().replace('.', '/'));
mv.visitFieldInsn(
PUTFIELD,
m_declaringTypeName,
fieldInfo.fieldName,
fieldInfo.mixinClassInfo.getSignature());
}
private static MethodVisitor insertThrowExceptionForFieldNotFound(MethodVisitor mv) {
mv.visitTypeInsn(NEW, "java/lang/IllegalArgumentException");
mv.visitInsn(DUP);
mv.visitTypeInsn(NEW, "java/lang/StringBuilder");
mv.visitInsn(DUP);
mv.visitLdcInsn("Field not found: ");
mv.visitMethodInsn(INVOKESPECIAL, "java/lang/StringBuilder", "<init>", "(Ljava/lang/String;)V");
mv.visitVarInsn(ILOAD, 2);
mv.visitMethodInsn(
INVOKEVIRTUAL, "java/lang/StringBuilder", "append", "(I)Ljava/lang/StringBuilder;");
mv.visitMethodInsn(
INVOKEVIRTUAL, "java/lang/StringBuilder", "toString", "()Ljava/lang/String;");
mv.visitMethodInsn(
INVOKESPECIAL, "java/lang/IllegalArgumentException", "<init>", "(Ljava/lang/String;)V");
mv.visitInsn(ATHROW);
return mv;
}
