Examples with CtClass org.hotswap.agent.javassist.CtClass used on opensource projects

Example 31 with CtClass

use of org.hotswap.agent.javassist.CtClass in project HotswapAgent by HotswapProjects.

the class ClassLoaderDefineClassPatcher method patch.

@Override
public void patch(final ClassLoader classLoaderFrom, final String pluginPath, final ClassLoader classLoaderTo, final ProtectionDomain protectionDomain) {
    List<byte[]> cache = getPluginCache(classLoaderFrom, pluginPath);
    if (cache != null) {
        final ClassPool cp = new ClassPool();
        cp.appendClassPath(new LoaderClassPath(getClass().getClassLoader()));
        for (byte[] pluginBytes : cache) {
            CtClass pluginClass = null;
            try {
                // force to load class in classLoaderFrom (it may not yet be loaded) and if the classLoaderTo
                // is parent of classLoaderFrom, after definition in classLoaderTo will classLoaderFrom return
                // class from parent classloader instead own definition (hence change of behaviour).
                InputStream is = new ByteArrayInputStream(pluginBytes);
                pluginClass = cp.makeClass(is);
                try {
                    classLoaderFrom.loadClass(pluginClass.getName());
                } catch (NoClassDefFoundError e) {
                    LOGGER.trace("Skipping class loading {} in classloader {} - " + "class has probably unresolvable dependency.", pluginClass.getName(), classLoaderTo);
                }
                // and load the class in classLoaderTo as well. NOw the class is defined in BOTH classloaders.
                pluginClass.toClass(classLoaderTo, protectionDomain);
            } catch (CannotCompileException e) {
                LOGGER.trace("Skipping class definition {} in app classloader {} - " + "class is probably already defined.", pluginClass.getName(), classLoaderTo);
            } catch (NoClassDefFoundError e) {
                LOGGER.trace("Skipping class definition {} in app classloader {} - " + "class has probably unresolvable dependency.", pluginClass.getName(), classLoaderTo);
            } catch (Throwable e) {
                LOGGER.trace("Skipping class definition app classloader {} - " + "unknown error.", e, classLoaderTo);
            }
        }
    }
    LOGGER.debug("Classloader {} patched with plugin classes from agent classloader {}.", classLoaderTo, classLoaderFrom);
}

Example 32 with CtClass

use of org.hotswap.agent.javassist.CtClass in project HotswapAgent by HotswapProjects.

the class Expr method mayThrow.

/**
 * Returns the list of exceptions that the expression may throw. This list
 * includes both the exceptions that the try-catch statements including the
 * expression can catch and the exceptions that the throws declaration
 * allows the method to throw.
 */
public CtClass[] mayThrow() {
    ClassPool pool = thisClass.getClassPool();
    ConstPool cp = thisMethod.getConstPool();
    LinkedList list = new LinkedList();
    try {
        CodeAttribute ca = thisMethod.getCodeAttribute();
        ExceptionTable et = ca.getExceptionTable();
        int pos = currentPos;
        int n = et.size();
        for (int i = 0; i < n; ++i) if (et.startPc(i) <= pos && pos < et.endPc(i)) {
            int t = et.catchType(i);
            if (t > 0)
                try {
                    addClass(list, pool.get(cp.getClassInfo(t)));
                } catch (NotFoundException e) {
                }
        }
    } catch (NullPointerException e) {
    }
    ExceptionsAttribute ea = thisMethod.getExceptionsAttribute();
    if (ea != null) {
        String[] exceptions = ea.getExceptions();
        if (exceptions != null) {
            int n = exceptions.length;
            for (int i = 0; i < n; ++i) try {
                addClass(list, pool.get(exceptions[i]));
            } catch (NotFoundException e) {
            }
        }
    }
    return (CtClass[]) list.toArray(new CtClass[list.size()]);
}

Example 33 with CtClass

use of org.hotswap.agent.javassist.CtClass in project HotswapAgent by HotswapProjects.

the class Expr method storeStack0.

private static void storeStack0(int i, int n, CtClass[] params, int regno, Bytecode bytecode) {
    if (i >= n)
        return;
    else {
        CtClass c = params[i];
        int size;
        if (c instanceof CtPrimitiveType)
            size = ((CtPrimitiveType) c).getDataSize();
        else
            size = 1;
        storeStack0(i + 1, n, params, regno + size, bytecode);
        bytecode.addStore(regno, c);
    }
}

Example 34 with CtClass

use of org.hotswap.agent.javassist.CtClass in project HotswapAgent by HotswapProjects.

the class TransformCall method matchClass.

private boolean matchClass(String name, ClassPool pool) {
    if (classname.equals(name))
        return true;
    try {
        CtClass clazz = pool.get(name);
        CtClass declClazz = pool.get(classname);
        if (clazz.subtypeOf(declClazz))
            try {
                CtMethod m = clazz.getMethod(methodname, methodDescriptor);
                return m.getDeclaringClass().getName().equals(classname);
            } catch (NotFoundException e) {
                // maybe the original method has been removed.
                return true;
            }
    } catch (NotFoundException e) {
        return false;
    }
    return false;
}

Example 35 with CtClass

use of org.hotswap.agent.javassist.CtClass in project HotswapAgent by HotswapProjects.

the class framedump method main.

/**
 * Main method.
 *
 * @param args <code>args[0]</code> is the class file name.
 */
public static void main(String[] args) throws Exception {
    if (args.length != 1) {
        System.err.println("Usage: java javassist.tools.framedump <fully-qualified class name>");
        return;
    }
    ClassPool pool = ClassPool.getDefault();
    CtClass clazz = pool.get(args[0]);
    System.out.println("Frame Dump of " + clazz.getName() + ":");
    FramePrinter.print(clazz, System.out);
}