public Type[] getArgumentTypes() { return Type.getArgumentTypes(desc); }
public PsSetMV(int access, String name, String desc, MethodVisitor mv, String owner) { super(ASM7,access, desc, mv); this.owner = owner; this.args = Type.getArgumentTypes(desc); this.name = name; }
/** * Creates a new {@link AdviceAdapter}. * * @param api the ASM API version implemented by this visitor. Must be one * of {@link Opcodes#ASM4} or {@link Opcodes#ASM7}. * @param mv the method visitor to which this adapter delegates calls. * @param access the method's access flags (see {@link Opcodes}). * @param name the method's name. * @param desc the method's descriptor (see {@link Type Type}). */ protected ReWriteMethod(int api, MethodVisitor mv, int access, String name, String desc) { super(api, mv, access, name, desc); this.argumentTypeArray = Type.getArgumentTypes(desc); }
/** Create a MethodInfo from ASM in-memory representation (an Android framework method). */ public MethodInfo(MethodNode method) { this.name = method.name; for (Type type : Type.getArgumentTypes(method.desc)) { paramTypes.add(normalize(type)); } }
/** * Returns the argument types of methods of this type. This method should only be used for method * types. * * @return the argument types of methods of this type. */ public Type[] getArgumentTypes() { return getArgumentTypes(getDescriptor()); }
public MethodBodyInsertor(MethodVisitor mv, String className, String desc, boolean isStatic, String methodId, String name, int access) { super(Opcodes.ASM5, mv, access, name, desc); this.className = className; this.returnType = Type.getReturnType(desc); Type[] argsType = Type.getArgumentTypes(desc); for (Type type : argsType) { paramsTypeClass.add(type); } this.isStatic = isStatic; this.methodId = methodId; }
private void addTypes(String desc) { Type[] types = Type.getArgumentTypes(desc); for (Type type : types) { addType(type); } }
public static MethodSignature parse(String internalString) { int parenStart = internalString.indexOf('('); int methodStart = internalString.lastIndexOf('/', parenStart); String className = internalString.substring(0, methodStart).replace('/', '.'); String methodName = internalString.substring(methodStart + 1, parenStart); String methodDescriptor = internalString.substring(parenStart); Type[] argumentTypes = Type.getArgumentTypes(methodDescriptor); String[] paramTypes = new String[argumentTypes.length]; for (int i = 0; i < argumentTypes.length; i++) { paramTypes[i] = argumentTypes[i].getClassName(); } final String returnType = Type.getReturnType(methodDescriptor).getClassName(); return new MethodSignature(className, methodName, paramTypes, returnType); }
private Method build(MtdInfo mapTo) { Type[] ts = Type.getArgumentTypes(mapTo.desc); String ss[] = new String[ts.length]; for (int i = 0; i < ss.length; i++) { ss[i] = ts[i].getDescriptor(); } return new Method(mapTo.owner, mapTo.name, ss, Type.getReturnType(mapTo.desc).getDescriptor()); }
private int countSignatureVariables(String desc) { int count = 1; for (Type paramType : Type.getArgumentTypes(desc)) { count += paramType.getSize(); } return count; }
public Signature(final ClassLoader loader, final MethodInsnNode method) { this.owners = expand(loader, method.owner); this.loader = loader; this.name = method.name; this.args = Type.getArgumentTypes(method.desc); }
String remapParams(String desc) { StringBuilder buf = new StringBuilder(); buf.append("("); for (Type type : Type.getArgumentTypes(desc)) { buf.append(remapParamType(type)); } buf.append(")"); buf.append(remapParamType(Type.getReturnType(desc))); return buf.toString(); }
static String getArgumentsInformation(String insnDesc) { if (insnDesc == null) { return ""; } Type methodType = Type.getMethodType(insnDesc); int argSize = methodType.getArgumentTypes().length; StringJoiner sj = new StringJoiner(",", "(", ")"); for (int i = 0; i < argSize; i++) { sj.add("_"); } return sj.toString(); }
IrMethod populate(String owner, MethodNode source) { IrMethod target = new IrMethod(); target.name = source.name; target.owner = "L" + owner + ";"; target.ret = Type.getReturnType(source.desc).getDescriptor(); Type[] args = Type.getArgumentTypes(source.desc); String sArgs[] = new String[args.length]; target.args = sArgs; for (int i = 0; i < args.length; i++) { sArgs[i] = args[i].getDescriptor(); } target.isStatic = 0 != (source.access & Opcodes.ACC_STATIC); return target; }
protected MtdInfo findTargetMethod0(Map<MtdInfo, MtdInfo> map, String owner, String name, String desc) { MtdInfo v = map.get(buildKey(owner, name, desc)); if (v != null) { return v; } // try with default ret key.desc = Type.getMethodDescriptor(Type.getType(DEFAULT_RET_TYPE), Type.getArgumentTypes(desc)); v = map.get(key); if (v != null) { return v; } // try with default desc key.desc = DEFAULT_DESC; v = map.get(key); if (v != null) { return v; } if (!name.equals("*")) { return findTargetMethod0(map, owner, "*", desc); } return v; }
public LocalVariablesSorter( final int access, final String desc, final MethodVisitor mv) { super(Constants.ASM_API, mv); state = new State(); Type[] args = Type.getArgumentTypes(desc); state.nextLocal = ((Opcodes.ACC_STATIC & access) != 0) ? 0 : 1; for (int i = 0; i < args.length; i++) { state.nextLocal += args[i].getSize(); } firstLocal = state.nextLocal; }
@Override public MethodVisitor visitMethod(int access, String methodName, String desc, String signature, String[] exceptions) { MethodVisitor mv = super.visitMethod(access, methodName, desc, signature, exceptions); if (mv == null || mset.isA(methodName, desc) == false) { return mv; } if (AsmUtil.isSpecial(methodName)) { return mv; } return new JspServletMV(access, desc, mv, Type.getArgumentTypes(desc), (access & ACC_STATIC) != 0); } }
public static int getIdxByType(int access, String desc, Type type) { Type[] t = Type.getArgumentTypes(desc); int sidx = (AsmUtil.isStatic(access) ? 0 : 1); for (int i = 0; t != null && i < t.length; i++) { if (type.equals(t[i])) { return sidx; } sidx += t[i].getSize(); } return -1; }
private void chooseMethodSignature() throws Exception { methodSignature = choice(getMethodSignatures()); int splitAt = methodSignature.indexOf('('); methodName = methodSignature.substring(0, splitAt); String methodDescriptor = methodSignature.substring(splitAt); Type[] asmTypes = Type.getArgumentTypes(methodDescriptor); params = new Class<?>[asmTypes.length]; //Get the corresponding class for each param type name for (int i = 0; i < asmTypes.length; i++) { params[i] = classForName(asmTypes[i].getClassName()); } }
private void chooseMethodSignature() throws Exception { methodDescriptor = choice(getMethodSignatures()); Type[] asmTypes = Type.getArgumentTypes(methodDescriptor); params = new Class<?>[asmTypes.length]; //Get the corresponding class for each param type name for (int i = 0; i < asmTypes.length; i++) { params[i] = classForName(asmTypes[i].getClassName()); } }