/* * Javassist, a Java-bytecode translator toolkit. * Copyright (C) 1999- Shigeru Chiba. All Rights Reserved. * * The contents of this file are subject to the Mozilla Public License Version * 1.1 (the "License"); you may not use this file except in compliance with * the License. Alternatively, the contents of this file may be used under * the terms of the GNU Lesser General Public License Version 2.1 or later, * or the Apache License Version 2.0. * * Software distributed under the License is distributed on an "AS IS" basis, * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License * for the specific language governing rights and limitations under the * License. */ package javassist; import javassist.bytecode.*; import javassist.compiler.Javac; import javassist.compiler.CompileError; import javassist.CtMethod.ConstParameter; /** * A collection of static methods for creating a CtMethod. * An instance of this class does not make any sense. * * @see CtClass#addMethod(CtMethod) */ public class CtNewMethod { /** * Compiles the given source code and creates a method. * The source code must include not only the method body * but the whole declaration, for example, * * * * @param src the source text. * @param declaring the class to which the created method is added. */ public static CtMethod make(String src, CtClass declaring) throws CannotCompileException { return make(src, declaring, null, null); } /** * Compiles the given source code and creates a method. * The source code must include not only the method body * but the whole declaration, for example, * * * *

If the source code includes $proceed(), then * it is compiled into a method call on the specified object. * * @param src the source text. * @param declaring the class to which the created method is added. * @param delegateObj the source text specifying the object * that is called on by $proceed(). * @param delegateMethod the name of the method * that is called by $proceed(). */ public static CtMethod make(String src, CtClass declaring, String delegateObj, String delegateMethod) throws CannotCompileException { Javac compiler = new Javac(declaring); try { if (delegateMethod != null) compiler.recordProceed(delegateObj, delegateMethod); CtMember obj = compiler.compile(src); if (obj instanceof CtMethod) return (CtMethod)obj; } catch (CompileError e) { throw new CannotCompileException(e); } throw new CannotCompileException("not a method"); } /** * Creates a public (non-static) method. The created method cannot * be changed to a static method later. * * @param returnType the type of the returned value. * @param mname the method name. * @param parameters a list of the parameter types. * @param exceptions a list of the exception types. * @param body the source text of the method body. * It must be a block surrounded by {}. * If it is null, the created method * does nothing except returning zero or null. * @param declaring the class to which the created method is added. * @see #make(int, CtClass, String, CtClass[], CtClass[], String, CtClass) */ public static CtMethod make(CtClass returnType, String mname, CtClass[] parameters, CtClass[] exceptions, String body, CtClass declaring) throws CannotCompileException { return make(Modifier.PUBLIC, returnType, mname, parameters, exceptions, body, declaring); } /** * Creates a method. modifiers can contain * Modifier.STATIC. * * @param modifiers access modifiers. * @param returnType the type of the returned value. * @param mname the method name. * @param parameters a list of the parameter types. * @param exceptions a list of the exception types. * @param body the source text of the method body. * It must be a block surrounded by {}. * If it is null, the created method * does nothing except returning zero or null. * @param declaring the class to which the created method is added. * * @see Modifier */ public static CtMethod make(int modifiers, CtClass returnType, String mname, CtClass[] parameters, CtClass[] exceptions, String body, CtClass declaring) throws CannotCompileException { try { CtMethod cm = new CtMethod(returnType, mname, parameters, declaring); cm.setModifiers(modifiers); cm.setExceptionTypes(exceptions); cm.setBody(body); return cm; } catch (NotFoundException e) { throw new CannotCompileException(e); } } /** * Creates a copy of a method. This method is provided for creating * a new method based on an existing method. * This is a convenience method for calling * {@link CtMethod#CtMethod(CtMethod, CtClass, ClassMap) this constructor}. * See the description of the constructor for particular behavior of the copying. * * @param src the source method. * @param declaring the class to which the created method is added. * @param map the hash table associating original class names * with substituted names. * It can be null. * * @see CtMethod#CtMethod(CtMethod,CtClass,ClassMap) */ public static CtMethod copy(CtMethod src, CtClass declaring, ClassMap map) throws CannotCompileException { return new CtMethod(src, declaring, map); } /** * Creates a copy of a method with a new name. * This method is provided for creating * a new method based on an existing method. * This is a convenience method for calling * {@link CtMethod#CtMethod(CtMethod, CtClass, ClassMap) this constructor}. * See the description of the constructor for particular behavior of the copying. * * @param src the source method. * @param name the name of the created method. * @param declaring the class to which the created method is added. * @param map the hash table associating original class names * with substituted names. * It can be null. * * @see CtMethod#CtMethod(CtMethod,CtClass,ClassMap) */ public static CtMethod copy(CtMethod src, String name, CtClass declaring, ClassMap map) throws CannotCompileException { CtMethod cm = new CtMethod(src, declaring, map); cm.setName(name); return cm; } /** * Creates a public abstract method. * * @param returnType the type of the returned value * @param mname the method name * @param parameters a list of the parameter types * @param exceptions a list of the exception types * @param declaring the class to which the created method is added. * * @see CtMethod#CtMethod(CtClass,String,CtClass[],CtClass) */ public static CtMethod abstractMethod(CtClass returnType, String mname, CtClass[] parameters, CtClass[] exceptions, CtClass declaring) throws NotFoundException { CtMethod cm = new CtMethod(returnType, mname, parameters, declaring); cm.setExceptionTypes(exceptions); return cm; } /** * Creates a public getter method. The getter method returns the value * of the specified field in the class to which this method is added. * The created method is initially not static even if the field is * static. Change the modifiers if the method should be static. * * @param methodName the name of the getter * @param field the field accessed. */ public static CtMethod getter(String methodName, CtField field) throws CannotCompileException { FieldInfo finfo = field.getFieldInfo2(); String fieldType = finfo.getDescriptor(); String desc = "()" + fieldType; ConstPool cp = finfo.getConstPool(); MethodInfo minfo = new MethodInfo(cp, methodName, desc); minfo.setAccessFlags(AccessFlag.PUBLIC); Bytecode code = new Bytecode(cp, 2, 1); try { String fieldName = finfo.getName(); if ((finfo.getAccessFlags() & AccessFlag.STATIC) == 0) { code.addAload(0); code.addGetfield(Bytecode.THIS, fieldName, fieldType); } else code.addGetstatic(Bytecode.THIS, fieldName, fieldType); code.addReturn(field.getType()); } catch (NotFoundException e) { throw new CannotCompileException(e); } minfo.setCodeAttribute(code.toCodeAttribute()); CtClass cc = field.getDeclaringClass(); // a stack map is not needed. return new CtMethod(minfo, cc); } /** * Creates a public setter method. The setter method assigns the * value of the first parameter to the specified field * in the class to which this method is added. * The created method is not static even if the field is * static. You may not change it to be static * by setModifiers() in CtBehavior. * * @param methodName the name of the setter * @param field the field accessed. */ public static CtMethod setter(String methodName, CtField field) throws CannotCompileException { FieldInfo finfo = field.getFieldInfo2(); String fieldType = finfo.getDescriptor(); String desc = "(" + fieldType + ")V"; ConstPool cp = finfo.getConstPool(); MethodInfo minfo = new MethodInfo(cp, methodName, desc); minfo.setAccessFlags(AccessFlag.PUBLIC); Bytecode code = new Bytecode(cp, 3, 3); try { String fieldName = finfo.getName(); if ((finfo.getAccessFlags() & AccessFlag.STATIC) == 0) { code.addAload(0); code.addLoad(1, field.getType()); code.addPutfield(Bytecode.THIS, fieldName, fieldType); } else { code.addLoad(1, field.getType()); code.addPutstatic(Bytecode.THIS, fieldName, fieldType); } code.addReturn(null); } catch (NotFoundException e) { throw new CannotCompileException(e); } minfo.setCodeAttribute(code.toCodeAttribute()); CtClass cc = field.getDeclaringClass(); // a stack map is not needed. return new CtMethod(minfo, cc); } /** * Creates a method forwarding to a delegate in * a super class. The created method calls a method specified * by delegate with all the parameters passed to the * created method. If the delegate method returns a value, * the created method returns that value to the caller. * The delegate method must be declared in a super class. * *

The following method is an example of the created method. * *

* *

The name of the created method can be changed by * setName(). * * @param delegate the method that the created method forwards to. * @param declaring the class to which the created method is * added. */ public static CtMethod delegator(CtMethod delegate, CtClass declaring) throws CannotCompileException { try { return delegator0(delegate, declaring); } catch (NotFoundException e) { throw new CannotCompileException(e); } } private static CtMethod delegator0(CtMethod delegate, CtClass declaring) throws CannotCompileException, NotFoundException { MethodInfo deleInfo = delegate.getMethodInfo2(); String methodName = deleInfo.getName(); String desc = deleInfo.getDescriptor(); ConstPool cp = declaring.getClassFile2().getConstPool(); MethodInfo minfo = new MethodInfo(cp, methodName, desc); minfo.setAccessFlags(deleInfo.getAccessFlags()); ExceptionsAttribute eattr = deleInfo.getExceptionsAttribute(); if (eattr != null) minfo.setExceptionsAttribute( (ExceptionsAttribute)eattr.copy(cp, null)); Bytecode code = new Bytecode(cp, 0, 0); boolean isStatic = Modifier.isStatic(delegate.getModifiers()); CtClass deleClass = delegate.getDeclaringClass(); CtClass[] params = delegate.getParameterTypes(); int s; if (isStatic) { s = code.addLoadParameters(params, 0); code.addInvokestatic(deleClass, methodName, desc); } else { code.addLoad(0, deleClass); s = code.addLoadParameters(params, 1); code.addInvokespecial(deleClass, methodName, desc); } code.addReturn(delegate.getReturnType()); code.setMaxLocals(++s); code.setMaxStack(s < 2 ? 2 : s); // for a 2-word return value minfo.setCodeAttribute(code.toCodeAttribute()); // a stack map is not needed. return new CtMethod(minfo, declaring); } /** * Creates a wrapped method. The wrapped method receives parameters * in the form of an array of Object. * *

The body of the created method is a copy of the body of the method * specified by body. However, it is wrapped in * parameter-conversion code. * *

The method specified by body must have this singature: * *

* *

The type of the cvalue depends on * constParam. * If constParam is null, the signature * must be: * *

* *

The method body copied from body is wrapped in * parameter-conversion code, which converts parameters specified by * parameterTypes into an array of Object. * The returned value is also converted from the Object * type to the type specified by returnType. Thus, * the resulting method body is as follows: * *

* *

The variables p0, p2, ... represent * formal parameters of the created method. * The value of cvalue is specified by * constParam. * *

If the type of a parameter or a returned value is a primitive * type, then the value is converted into a wrapper object such as * java.lang.Integer. If the type of the returned value * is void, the returned value is discarded. * *

Example: * *

* *

where the class Sample is as follows: * *

* *

This program produces a class intVector: * *

* *

Note that the type of the parameter to add() depends * only on the value of argTypes passed to * CtNewMethod.wrapped(). Thus, it is easy to * modify this program to produce a * StringVector class, which is a vector containing * only String objects, and other vector classes. * * @param returnType the type of the returned value. * @param mname the method name. * @param parameterTypes a list of the parameter types. * @param exceptionTypes a list of the exception types. * @param body the method body * (must not be a static method). * @param constParam the constant parameter * (maybe null). * @param declaring the class to which the created method is * added. */ public static CtMethod wrapped(CtClass returnType, String mname, CtClass[] parameterTypes, CtClass[] exceptionTypes, CtMethod body, ConstParameter constParam, CtClass declaring) throws CannotCompileException { return CtNewWrappedMethod.wrapped(returnType, mname, parameterTypes, exceptionTypes, body, constParam, declaring); } }