Java MethodInfo類代碼示例

import scouter.javassist.bytecode.MethodInfo; //導入依賴的package包/類
public static CtMethod wrapped(CtClass returnType, String mname,
                               CtClass[] parameterTypes,
                               CtClass[] exceptionTypes,
                               CtMethod body, ConstParameter constParam,
                               CtClass declaring)
    throws CannotCompileException
{
    CtMethod mt = new CtMethod(returnType, mname, parameterTypes,
                               declaring);
    mt.setModifiers(body.getModifiers());
    try {
        mt.setExceptionTypes(exceptionTypes);
    }
    catch (NotFoundException e) {
        throw new CannotCompileException(e);
    }

    Bytecode code = makeBody(declaring, declaring.getClassFile2(), body,
                             parameterTypes, returnType, constParam);
    MethodInfo minfo = mt.getMethodInfo2();
    minfo.setCodeAttribute(code.toCodeAttribute());
    // a stack map has been already created. 
    return mt;
}
 

import scouter.javassist.bytecode.MethodInfo; //導入依賴的package包/類
public Subroutine[] scan(MethodInfo method) throws BadBytecode {
    CodeAttribute code = method.getCodeAttribute();
    CodeIterator iter = code.iterator();

    subroutines = new Subroutine[code.getCodeLength()];
    subTable.clear();
    done.clear();

    scan(0, iter, null);

    ExceptionTable exceptions = code.getExceptionTable();
    for (int i = 0; i < exceptions.size(); i++) {
        int handler = exceptions.handlerPc(i);
        // If an exception is thrown in subroutine, the handler
        // is part of the same subroutine.
        scan(handler, iter, subroutines[exceptions.startPc(i)]);
    }

    return subroutines;
}
 

import scouter.javassist.bytecode.MethodInfo; //導入依賴的package包/類
private ExceptionInfo[] buildExceptionInfo(MethodInfo method) {
    ConstPool constPool = method.getConstPool();
    ClassPool classes = clazz.getClassPool();

    ExceptionTable table = method.getCodeAttribute().getExceptionTable();
    ExceptionInfo[] exceptions = new ExceptionInfo[table.size()];
    for (int i = 0; i < table.size(); i++) {
        int index = table.catchType(i);
        Type type;
        try {
            type = index == 0 ? Type.THROWABLE : Type.get(classes.get(constPool.getClassInfo(index)));
        } catch (NotFoundException e) {
            throw new IllegalStateException(e.getMessage());
        }

        exceptions[i] = new ExceptionInfo(table.startPc(i), table.endPc(i), table.handlerPc(i), type);
    }

    return exceptions;
}
 

import scouter.javassist.bytecode.MethodInfo; //導入依賴的package包/類
private Frame firstFrame(MethodInfo method, int maxLocals, int maxStack) {
    int pos = 0;

    Frame first = new Frame(maxLocals, maxStack);
    if ((method.getAccessFlags() & AccessFlag.STATIC) == 0) {
        first.setLocal(pos++, Type.get(clazz));
    }

    CtClass[] parameters;
    try {
        parameters = Descriptor.getParameterTypes(method.getDescriptor(), clazz.getClassPool());
    } catch (NotFoundException e) {
        throw new RuntimeException(e);
    }

    for (int i = 0; i < parameters.length; i++) {
        Type type = zeroExtend(Type.get(parameters[i]));
        first.setLocal(pos++, type);
        if (type.getSize() == 2)
            first.setLocal(pos++, Type.TOP);
    }

    return first;
}
 

import scouter.javassist.bytecode.MethodInfo; //導入依賴的package包/類
/**
 * Divides the method body into basic blocks.
 * The type information of the first block is initialized.
 *
 * @param optimize       if it is true and the method does not include
 *                      branches, this method returns null.
 */
public static TypedBlock[] makeBlocks(MethodInfo minfo, CodeAttribute ca,
                                      boolean optimize)
    throws BadBytecode
{
    TypedBlock[] blocks = (TypedBlock[])new Maker().make(minfo);
    if (optimize && blocks.length < 2)
        if (blocks.length == 0 || blocks[0].incoming == 0)
            return null;

    ConstPool pool = minfo.getConstPool();
    boolean isStatic = (minfo.getAccessFlags() & AccessFlag.STATIC) != 0;
    blocks[0].initFirstBlock(ca.getMaxStack(), ca.getMaxLocals(),
                             pool.getClassName(), minfo.getDescriptor(),
                             isStatic, minfo.isConstructor());
    return blocks;
}
 

import scouter.javassist.bytecode.MethodInfo; //導入依賴的package包/類
private void override(String thisClassname, Method meth, String prefix,
                      int index, String desc, ClassFile cf, ConstPool cp, ArrayList forwarders)
    throws CannotCompileException
{
    Class declClass = meth.getDeclaringClass();
    String delegatorName = prefix + index + meth.getName();
    if (Modifier.isAbstract(meth.getModifiers()))
        delegatorName = null;
    else {
        MethodInfo delegator
            = makeDelegator(meth, desc, cp, declClass, delegatorName);
        // delegator is not a bridge method.  See Sec. 15.12.4.5 of JLS 3rd Ed.
        delegator.setAccessFlags(delegator.getAccessFlags() & ~AccessFlag.BRIDGE);
        cf.addMethod(delegator);
    }

    MethodInfo forwarder
        = makeForwarder(thisClassname, meth, desc, cp, declClass,
                        delegatorName, index, forwarders);
    cf.addMethod(forwarder);
}
 

import scouter.javassist.bytecode.MethodInfo; //導入依賴的package包/類
private void makeConstructors(String thisClassName, ClassFile cf,
        ConstPool cp, String classname) throws CannotCompileException
{
    Constructor[] cons = SecurityActions.getDeclaredConstructors(superClass);
    // legacy: if we are not caching then we need to initialise the default handler
    boolean doHandlerInit = !factoryUseCache;
    for (int i = 0; i < cons.length; i++) {
        Constructor c = cons[i];
        int mod = c.getModifiers();
        if (!Modifier.isFinal(mod) && !Modifier.isPrivate(mod)
                && isVisible(mod, basename, c)) {
            MethodInfo m = makeConstructor(thisClassName, c, cp, superClass, doHandlerInit);
            cf.addMethod(m);
        }
    }
}
 

import scouter.javassist.bytecode.MethodInfo; //導入依賴的package包/類
private MethodInfo makeDelegator(Method meth, String desc,
            ConstPool cp, Class declClass, String delegatorName) {
    MethodInfo delegator = new MethodInfo(cp, delegatorName, desc);
    delegator.setAccessFlags(Modifier.FINAL | Modifier.PUBLIC
            | (meth.getModifiers() & ~(Modifier.PRIVATE
                                       | Modifier.PROTECTED
                                       | Modifier.ABSTRACT
                                       | Modifier.NATIVE
                                       | Modifier.SYNCHRONIZED)));
    setThrows(delegator, cp, meth);
    Bytecode code = new Bytecode(cp, 0, 0);
    code.addAload(0);
    int s = addLoadParameters(code, meth.getParameterTypes(), 1);
    Class targetClass = invokespecialTarget(declClass);
    code.addInvokespecial(targetClass.isInterface(), cp.addClassInfo(targetClass.getName()),
                          meth.getName(), desc);
    addReturn(code, meth.getReturnType());
    code.setMaxLocals(++s);
    delegator.setCodeAttribute(code.toCodeAttribute());
    return delegator;
}
 

import scouter.javassist.bytecode.MethodInfo; //導入依賴的package包/類
private static MethodInfo makeWriteReplace(ConstPool cp) {
    MethodInfo minfo = new MethodInfo(cp, "writeReplace", "()Ljava/lang/Object;");
    String[] list = new String[1];
    list[0] = "java.io.ObjectStreamException";
    ExceptionsAttribute ea = new ExceptionsAttribute(cp);
    ea.setExceptions(list);
    minfo.setExceptionsAttribute(ea);
    Bytecode code = new Bytecode(cp, 0, 1);
    code.addAload(0);
    code.addInvokestatic("RuntimeSupport",
                         "makeSerializedProxy",
                         "(Ljava/lang/Object;)Ljavassist/util/proxy/SerializedProxy;");
    code.addOpcode(Opcode.ARETURN);
    minfo.setCodeAttribute(code.toCodeAttribute());
    return minfo;
}
 

import scouter.javassist.bytecode.MethodInfo; //導入依賴的package包/類
public CtBehavior getEnclosingBehavior() throws NotFoundException {
    ClassFile cf = getClassFile2();
    EnclosingMethodAttribute ema
            = (EnclosingMethodAttribute)cf.getAttribute(
                                            EnclosingMethodAttribute.tag);
    if (ema == null)
        return null;
    else {
        CtClass enc = classPool.get(ema.className());
        String name = ema.methodName();
        if (MethodInfo.nameInit.equals(name))
            return enc.getConstructor(ema.methodDescriptor());
        else if(MethodInfo.nameClinit.equals(name))
            return enc.getClassInitializer();
        else
            return enc.getMethod(name, ema.methodDescriptor());
    }
}
 

import scouter.javassist.bytecode.MethodInfo; //導入依賴的package包/類
/**
 * Visits each bytecode in the given range. 
 */
boolean doit(CtClass clazz, MethodInfo minfo, LoopContext context,
             CodeIterator iterator, int endPos)
    throws CannotCompileException
{
    boolean edited = false;
    while (iterator.hasNext() && iterator.lookAhead() < endPos) {
        int size = iterator.getCodeLength();
        if (loopBody(iterator, clazz, minfo, context)) {
            edited = true;
            int size2 = iterator.getCodeLength();
            if (size != size2)  // the body was modified.
                endPos += size2 - size;
        }
    }

    return edited;
}
 

import scouter.javassist.bytecode.MethodInfo; //導入依賴的package包/類
public void atNewExpr(NewExpr expr) throws CompileError {
    if (expr.isArray())
        atNewArrayExpr(expr);
    else {
        CtClass clazz = resolver.lookupClassByName(expr.getClassName());
        String cname = clazz.getName();
        ASTList args = expr.getArguments();
        bytecode.addNew(cname);
        bytecode.addOpcode(DUP);

        atMethodCallCore(clazz, MethodInfo.nameInit, args,
                         false, true, -1, null);

        exprType = CLASS;
        arrayDim = 0;
        className = MemberResolver.javaToJvmName(cname);
    }
}
 

import scouter.javassist.bytecode.MethodInfo; //導入依賴的package包/類
private void atFieldAssignCore(CtField f, boolean is_static, int fi,
                               boolean is2byte) throws CompileError {
    if (fi != 0) {
        if (is_static) {
           bytecode.add(PUTSTATIC);
           bytecode.growStack(is2byte ? -2 : -1);
        }
        else {
            bytecode.add(PUTFIELD);
            bytecode.growStack(is2byte ? -3 : -2);
        }
    
        bytecode.addIndex(fi);
    }
    else {
        CtClass declClass = f.getDeclaringClass();
        AccessorMaker maker = declClass.getAccessorMaker();
        // make should be non null.
        FieldInfo finfo = f.getFieldInfo2();
        MethodInfo minfo = maker.getFieldSetter(finfo, is_static);
        bytecode.addInvokestatic(declClass, minfo.getName(),
                                 minfo.getDescriptor());
    }
}
 

import scouter.javassist.bytecode.MethodInfo; //導入依賴的package包/類
/**
 * Generates bytecode for reading a field value.
 * It returns a fieldref_info index or zero if the field is a private
 * one declared in an enclosing class. 
 */
private int atFieldRead(CtField f, boolean isStatic) throws CompileError {
    FieldInfo finfo = f.getFieldInfo2();
    boolean is2byte = setFieldType(finfo);
    AccessorMaker maker = isAccessibleField(f, finfo);
    if (maker != null) {
        MethodInfo minfo = maker.getFieldGetter(finfo, isStatic);
        bytecode.addInvokestatic(f.getDeclaringClass(), minfo.getName(),
                                 minfo.getDescriptor());
        return 0;
    }
    else {
        int fi = addFieldrefInfo(f, finfo);
        if (isStatic) {
            bytecode.add(GETSTATIC);
            bytecode.growStack(is2byte ? 2 : 1);
        }
        else {
            bytecode.add(GETFIELD);
            bytecode.growStack(is2byte ? 1 : 0);
        }

        bytecode.addIndex(fi);
        return fi;
    }
}
 

import scouter.javassist.bytecode.MethodInfo; //導入依賴的package包/類
private Object getDefault(String name, Method method)
    throws ClassNotFoundException, RuntimeException
{
    String classname = annotation.getTypeName();
    if (pool != null) {
        try {
            CtClass cc = pool.get(classname);
            ClassFile cf = cc.getClassFile2();
            MethodInfo minfo = cf.getMethod(name);
            if (minfo != null) {
                AnnotationDefaultAttribute ainfo
                    = (AnnotationDefaultAttribute)
                      minfo.getAttribute(AnnotationDefaultAttribute.tag);
                if (ainfo != null) {
                    MemberValue mv = ainfo.getDefaultValue();
                    return mv.getValue(classLoader, pool, method);
                }
            }
        }
        catch (NotFoundException e) {
            throw new RuntimeException("cannot find a class file: "
                                       + classname);
        }
    }

    throw new RuntimeException("no default value: " + classname + "."
                               + name + "()");
}