import net.bytebuddy.jar.asm.MethodVisitor; //导入依赖的package包/类
@Override
public Size apply(MethodVisitor methodVisitor, Context implementationContext) {
  final int opcode;
  Size size = new Size(-StackSize.of(variableType).getSize() * 2, 0);
  if (variableType == int.class || variableType == boolean.class) {
    opcode = Opcodes.IF_ICMPEQ;
  } else if (variableType == long.class) {
    methodVisitor.visitInsn(Opcodes.LCMP);
    opcode = Opcodes.IFEQ;
  } else if (variableType == float.class) {
    methodVisitor.visitInsn(Opcodes.FCMPG);
    opcode = Opcodes.IFEQ;
  } else if (variableType == double.class) {
    methodVisitor.visitInsn(Opcodes.DCMPG);
    opcode = Opcodes.IFEQ;
  } else {
    // Reference type comparison assumes the result of Object.equals is already on the stack.
    opcode = Opcodes.IFNE;
    // There is only a boolean on the stack, so we only consume one item, unlike the others that
    // consume both.
    size = new Size(-1, 0);
  }
  methodVisitor.visitJumpInsn(opcode, destination);
  return size;
}
 

import net.bytebuddy.jar.asm.MethodVisitor; //导入依赖的package包/类
private void visitFrame(
    MethodVisitor mv, boolean localsIncludeReturn, @Nullable String stackTop) {
  boolean hasReturnLocal = (returnVarIndex != null) && localsIncludeReturn;

  Type[] localTypes = Type.getArgumentTypes(instrumentedMethod.getDescriptor());
  Object[] locals = new Object[1 + localTypes.length + (hasReturnLocal ? 1 : 0)];
  locals[0] = instrumentedMethod.getReceiverType().asErasure().getInternalName();
  for (int i = 0; i < localTypes.length; i++) {
    locals[i + 1] = describeType(localTypes[i]);
  }
  if (hasReturnLocal) {
    locals[locals.length - 1] = returnType.getInternalName();
  }

  Object[] stack = stackTop == null ? new Object[] {} : new Object[] {stackTop};

  mv.visitFrame(Opcodes.F_NEW, locals.length, locals, stack.length, stack);
}
 

import net.bytebuddy.jar.asm.MethodVisitor; //导入依赖的package包/类
public Size apply(MethodVisitor methodVisitor, Implementation.Context implementationContext) {
  switch (variableIndex) {
    case 0:
      methodVisitor.visitInsn(storeOpcode + storeOpcodeShortcutOffset);
      break;
    case 1:
      methodVisitor.visitInsn(storeOpcode + storeOpcodeShortcutOffset + 1);
      break;
    case 2:
      methodVisitor.visitInsn(storeOpcode + storeOpcodeShortcutOffset + 2);
      break;
    case 3:
      methodVisitor.visitInsn(storeOpcode + storeOpcodeShortcutOffset + 3);
      break;
    default:
      methodVisitor.visitVarInsn(storeOpcode, variableIndex);
      break;
  }
  return size;
}
 

import net.bytebuddy.jar.asm.MethodVisitor; //导入依赖的package包/类
public Size apply(MethodVisitor methodVisitor, Implementation.Context implementationContext,
    MethodDescription instrumentedMethod) {

  checkMethodSignature(instrumentedMethod);

  try {
    StackManipulation stack = buildStack();
    StackManipulation.Size finalStackSize = stack.apply(methodVisitor, implementationContext);

    return new Size(finalStackSize.getMaximalSize(),
        instrumentedMethod.getStackSize() + 2); // 2 stack slots for a single local variable

  } catch (NoSuchMethodException | NoSuchFieldException e) {
    throw new RuntimeException(e);
  }
}
 

import net.bytebuddy.jar.asm.MethodVisitor; //导入依赖的package包/类
@Override
public Size apply(MethodVisitor methodVisitor, Implementation.Context implementationContext,
                MethodDescription instrumentedMethod) {
    switch (returnType) {
        case REFERENCE:
            return new Size(MethodReturn.REFERENCE.apply(methodVisitor, implementationContext).getMaximalSize(),
                            instrumentedMethod.getStackSize());
        case VOID:
            return new Size(MethodReturn.VOID.apply(methodVisitor, implementationContext).getMaximalSize(),
                            instrumentedMethod.getStackSize());
        case INT:
            return new Size(MethodReturn.INTEGER.apply(methodVisitor, implementationContext).getMaximalSize(),
                            instrumentedMethod.getStackSize());
        default:
            throw new IllegalStateException("Illegal opType");
    }

}
 

import net.bytebuddy.jar.asm.MethodVisitor; //导入依赖的package包/类
@Override
public Size apply(MethodVisitor methodVisitor, Implementation.Context implementationContext,
                MethodDescription instrumentedMethod) {
    int numArgs = instrumentedMethod.getParameters().asTypeList().getStackSize();
    /**
     * Load the desired id
     * relative to the method arguments.
     * The idea here would be to load references
     * to declared variables
     */
    //references start with zero if its an instance or zero if its static
    //think of it like an implicit self in python without actually being defined
    int start = instrumentedMethod.isStatic() ? 1 : 0;
    StackManipulation arg0 = MethodVariableAccess.REFERENCE
                    .loadOffset(numArgs + start + OpCodeUtil.getAloadInstructionForReference(refId));
    StackManipulation.Size size = arg0.apply(methodVisitor, implementationContext);
    return new Size(size.getMaximalSize(), instrumentedMethod.getStackSize());
}
 

import net.bytebuddy.jar.asm.MethodVisitor; //导入依赖的package包/类
@Override
public ByteCodeAppender.Size apply(MethodVisitor mv, Implementation.Context p2, MethodDescription p3) {
	mv.visitVarInsn(ALOAD, 0);
	mv.visitMethodInsn(INVOKESPECIAL, "br/com/brjdevs/highhacks/eventbus/ASMEventHandler", "<init>", "()V", false);
	if (!isStatic) {
		mv.visitVarInsn(ALOAD, 0);
		mv.visitVarInsn(ALOAD, 1);
		mv.visitFieldInsn(PUTFIELD, thisClass, "instance", "Ljava/lang/Object;");
	}
	mv.visitInsn(RETURN);
	mv.visitMaxs(2, 2);
	return new ByteCodeAppender.Size(2, 2);
}
 

import net.bytebuddy.jar.asm.MethodVisitor; //导入依赖的package包/类
@Override
public ByteCodeAppender.Size apply(MethodVisitor mv, Implementation.Context implementationContext, MethodDescription instrumentedMethod) {
	mv.visitVarInsn(ALOAD, 0);
	if (!isStatic) {
		mv.visitFieldInsn(GETFIELD, thisClass, "instance", "Ljava/lang/Object;");
		mv.visitTypeInsn(CHECKCAST, listenerClass);
	}
	mv.visitVarInsn(ALOAD, 1);
	mv.visitTypeInsn(CHECKCAST, eventClass);
	mv.visitMethodInsn(isStatic ? INVOKESTATIC : INVOKEVIRTUAL, listenerClass, callback.getName(), Type.getMethodDescriptor(callback), false);
	mv.visitInsn(RETURN);
	mv.visitMaxs(2, 2);
	return new Size(2, 2);
}
 

import net.bytebuddy.jar.asm.MethodVisitor; //导入依赖的package包/类
@Override
public Size apply(
    MethodVisitor methodVisitor,
    Context implementationContext,
    MethodDescription instrumentedMethod) {
  Map<String, FieldDescription> fieldsByName = CodeGenUtil.fieldsByName(implementationContext);
  StackManipulation.Size operandStackSize =
      new StackManipulation.Compound(
              new TextConstant(unserializedFieldValue),
              SerializeSupport_serializeString,
              FieldAccess.forField(fieldsByName.get(fieldName)).write())
          .apply(methodVisitor, implementationContext);
  return new Size(operandStackSize.getMaximalSize(), instrumentedMethod.getStackSize());
}
 

import net.bytebuddy.jar.asm.MethodVisitor; //导入依赖的package包/类
@Override
public ByteCodeAppender appender(final Target implementationTarget) {
  return new ByteCodeAppender() {
    @Override
    public Size apply(
        MethodVisitor methodVisitor,
        Context implementationContext,
        MethodDescription instrumentedMethod) {
      StackManipulation.Size size =
          new StackManipulation.Compound(
                  // Load the this reference
                  MethodVariableAccess.REFERENCE.loadFrom(0),
                  // Load the delegate argument
                  MethodVariableAccess.REFERENCE.loadFrom(1),
                  // Invoke the super constructor (default constructor of Object)
                  MethodInvocation.invoke(
                      new TypeDescription.ForLoadedType(DoFnInvokerBase.class)
                          .getDeclaredMethods()
                          .filter(
                              ElementMatchers.isConstructor()
                                  .and(ElementMatchers.takesArguments(DoFn.class)))
                          .getOnly()),
                  // Return void.
                  MethodReturn.VOID)
              .apply(methodVisitor, implementationContext);
      return new Size(size.getMaximalSize(), instrumentedMethod.getStackSize());
    }
  };
}
 

import net.bytebuddy.jar.asm.MethodVisitor; //导入依赖的package包/类
@Override
public ByteCodeAppender appender(final Target implementationTarget) {
  return new ByteCodeAppender() {
    @Override
    public Size apply(
        MethodVisitor methodVisitor,
        Context implementationContext,
        MethodDescription instrumentedMethod) {
      StackManipulation.Size size =
          new StackManipulation.Compound(
                  // Load the this reference
                  MethodVariableAccess.REFERENCE.loadFrom(0),
                  // Invoke the super constructor (default constructor of Object)
                  MethodInvocation.invoke(
                      new TypeDescription.ForLoadedType(Object.class)
                          .getDeclaredMethods()
                          .filter(
                              ElementMatchers.isConstructor()
                                  .and(ElementMatchers.takesArguments(0)))
                          .getOnly()),
                  // Load the this reference
                  MethodVariableAccess.REFERENCE.loadFrom(0),
                  // Load the delegate argument
                  MethodVariableAccess.REFERENCE.loadFrom(1),
                  // Assign the delegate argument to the delegate field
                  FieldAccess.forField(
                          implementationTarget
                              .getInstrumentedType()
                              .getDeclaredFields()
                              .filter(ElementMatchers.named(FN_DELEGATE_FIELD_NAME))
                              .getOnly())
                      .write(),
                  // Return void.
                  MethodReturn.VOID)
              .apply(methodVisitor, implementationContext);
      return new Size(size.getMaximalSize(), instrumentedMethod.getStackSize());
    }
  };
}
 

import net.bytebuddy.jar.asm.MethodVisitor; //导入依赖的package包/类
@Override
public Size apply(MethodVisitor methodVisitor, Implementation.Context implementationContext,
                MethodDescription instrumentedMethod) {
    //initialize the stack with the array access with this as reference 0 and the array (first argument) as reference 1
    StackManipulation compound = assignOperation();
    StackManipulation.Size size = compound.apply(methodVisitor, implementationContext);
    //resolve the opType to store in the array and retrieve the load command
    StackManipulation store = ArrayAccess.of(typePool.describe("int").resolve()).load();
    size = size.aggregate(store.apply(methodVisitor, implementationContext));
    return new Size(size.getMaximalSize(), instrumentedMethod.getStackSize());
}
 

import net.bytebuddy.jar.asm.MethodVisitor; //导入依赖的package包/类
@Override
public Size apply(MethodVisitor methodVisitor, Implementation.Context implementationContext,
                MethodDescription instrumentedMethod) {
    //resolve the opType to store in the array and retrieve the store command
    StackManipulation store = ArrayAccess.of(typePool.describe("int").resolve()).load();
    StackManipulation.Size size = store.apply(methodVisitor, implementationContext);
    return new Size(size.getMaximalSize(), instrumentedMethod.getStackSize());
}
 

import net.bytebuddy.jar.asm.MethodVisitor; //导入依赖的package包/类
@Override
public Size apply(MethodVisitor methodVisitor, Implementation.Context implementationContext,
                MethodDescription instrumentedMethod) {
    //resolve the opType to store in the array and retrieve the store command
    StackManipulation store = ArrayAccess.of(typePool.describe("int").resolve()).store();
    StackManipulation.Size size = store.apply(methodVisitor, implementationContext);
    return new Size(size.getMaximalSize(), instrumentedMethod.getStackSize());
}
 

import net.bytebuddy.jar.asm.MethodVisitor; //导入依赖的package包/类
@Override
public Size apply(MethodVisitor methodVisitor, Implementation.Context implementationContext,
                MethodDescription instrumentedMethod) {
    //initialize the stack with the array access with this as reference 0 and the array (first argument) as reference 1
    StackManipulation compound = assignOperation();
    StackManipulation.Size size = compound.apply(methodVisitor, implementationContext);
    //resolve the opType to store in the array and retrieve the store command
    StackManipulation store = ArrayAccess.of(typePool.describe("int").resolve()).store();
    size = size.aggregate(store.apply(methodVisitor, implementationContext));
    return new Size(size.getMaximalSize(), instrumentedMethod.getStackSize());
}
 

import net.bytebuddy.jar.asm.MethodVisitor; //导入依赖的package包/类
@Override
public Size apply(MethodVisitor methodVisitor, Implementation.Context implementationContext,
                MethodDescription instrumentedMethod) {
    //initialize the stack with the array access with this as reference 0 and the array (first argument) as reference 1
    StackManipulation compound = assignOperation();
    StackManipulation.Size size = compound.apply(methodVisitor, implementationContext);
    //resolve the opType to store in the array and retrieve the store command
    StackManipulation store = ArrayAccess.of(typePool.describe("int").resolve()).store();
    size = size.aggregate(store.apply(methodVisitor, implementationContext));
    //set the return opType (ALWAYS REMEMBER TO DO THIS)
    StackManipulation returnOp = MethodReturn.VOID;
    size = size.aggregate(returnOp.apply(methodVisitor, implementationContext));
    return new Size(size.getMaximalSize(), instrumentedMethod.getStackSize());
}
 

import net.bytebuddy.jar.asm.MethodVisitor; //导入依赖的package包/类
@Override
public Size apply(MethodVisitor methodVisitor, Implementation.Context implementationContext,
                MethodDescription instrumentedMethod) {
    StackManipulation createArray = RelativeIntArrayCreation.intCreationOfLength(length);
    StackManipulation.Compound size = new StackManipulation.Compound(createArray);

    StackManipulation.Size size1 = size.apply(methodVisitor, implementationContext);
    return new Size(size1.getMaximalSize(), instrumentedMethod.getStackSize());

}
 

import net.bytebuddy.jar.asm.MethodVisitor; //导入依赖的package包/类
@Override
public Size apply(MethodVisitor methodVisitor, Implementation.Context implementationContext,
                MethodDescription instrumentedMethod) {
    StackManipulation createArray = IntArrayCreation.intCreationOfLength(length);
    StackManipulation.Compound size = new StackManipulation.Compound(createArray);

    StackManipulation.Size size1 = size.apply(methodVisitor, implementationContext);
    return new Size(size1.getMaximalSize(), instrumentedMethod.getStackSize());

}
 

import net.bytebuddy.jar.asm.MethodVisitor; //导入依赖的package包/类
@Override
public Size apply(MethodVisitor methodVisitor, Implementation.Context implementationContext,
                MethodDescription instrumentedMethod) {
    StackManipulation createArray = IntArrayCreation.intCreationOfLength(length);
    StackManipulation.Compound size = new StackManipulation.Compound(createArray, MethodReturn.REFERENCE);

    StackManipulation.Size size1 = size.apply(methodVisitor, implementationContext);
    return new Size(size1.getMaximalSize(), instrumentedMethod.getStackSize());

}
 

import net.bytebuddy.jar.asm.MethodVisitor; //导入依赖的package包/类
@Override
public Size apply(MethodVisitor methodVisitor, Implementation.Context implementationContext,
                MethodDescription instrumentedMethod) {
    StackManipulation.Size size = IntegerConstant.forValue(length).apply(methodVisitor, implementationContext);
    methodVisitor.visitIntInsn(Opcodes.NEWARRAY, Opcodes.T_INT);
    return new Size(size.getMaximalSize(), size.getSizeImpact());
}