/*******************************************************************************
* Copyright (c) 2002 - 2006 IBM Corporation.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package com.ibm.wala.types;
import java.util.HashMap;
import com.ibm.wala.classLoader.Language;
import com.ibm.wala.util.collections.HashMapFactory;
import com.ibm.wala.util.shrike.ShrikeUtil;
import com.ibm.wala.util.strings.Atom;
/**
* A class to represent the reference in a class file to a method.
*/
public final class MethodReference extends MemberReference {
/**
* Used to canonicalize MethodReferences a mapping from Key -> MethodReference
*/
final private static HashMap<Key, MethodReference> dictionary = HashMapFactory.make();
public final static Atom newInstanceAtom = Atom.findOrCreateUnicodeAtom("newInstance");
private final static Descriptor newInstanceDesc = Descriptor.findOrCreateUTF8(Language.JAVA, "()Ljava/lang/Object;");
public final static MethodReference JavaLangClassNewInstance = findOrCreate(TypeReference.JavaLangClass, newInstanceAtom,
newInstanceDesc);
private final static Atom ctorNewInstanceAtom = Atom.findOrCreateUnicodeAtom("newInstance");
private final static Descriptor ctorNewInstanceDesc = Descriptor.findOrCreateUTF8(Language.JAVA, "([Ljava/lang/Object;)Ljava/lang/Object;");
public final static MemberReference JavaLangReflectCtorNewInstance = findOrCreate(TypeReference.JavaLangReflectConstructor,
ctorNewInstanceAtom, ctorNewInstanceDesc);
public final static Atom forNameAtom = Atom.findOrCreateUnicodeAtom("forName");
private final static Descriptor forNameDesc = Descriptor.findOrCreateUTF8(Language.JAVA, "(Ljava/lang/String;)Ljava/lang/Class;");
public final static MethodReference JavaLangClassForName = findOrCreate(TypeReference.JavaLangClass, forNameAtom, forNameDesc);
public final static Atom initAtom = Atom.findOrCreateUnicodeAtom("<init>");
public final static Descriptor defaultInitDesc = Descriptor.findOrCreateUTF8(Language.JAVA, "()V");
public final static Selector initSelector = new Selector(initAtom, defaultInitDesc);
public final static Atom clinitName = Atom.findOrCreateUnicodeAtom("<clinit>");
public final static Selector clinitSelector = new Selector(clinitName, defaultInitDesc);
public final static Atom runAtom = Atom.findOrCreateUnicodeAtom("run");
public final static Descriptor runDesc = Descriptor.findOrCreateUTF8(Language.JAVA, "()Ljava/lang/Object;");
public final static Selector runSelector = new Selector(runAtom, runDesc);
public final static Atom equalsAtom = Atom.findOrCreateUnicodeAtom("equals");
public final static Descriptor equalsDesc = Descriptor.findOrCreateUTF8(Language.JAVA, "(Ljava/lang/Object;)Z");
public final static Selector equalsSelector = new Selector(equalsAtom, equalsDesc);
/**
* types of parameters to this method.
*/
final private TypeReference[] parameterTypes;
/**
* return type.
*/
private final TypeReference returnType;
/**
* Name and descriptor
*/
private final Selector selector;
/**
* Find or create the canonical MethodReference instance for the given tuple.
*
* @param mn the name of the member
* @param md the descriptor of the member
*/
public static synchronized MethodReference findOrCreate(TypeReference tref, Atom mn, Descriptor md) {
if (tref == null) {
throw new IllegalArgumentException("null tref");
}
Key key = new Key(tref, mn, md);
MethodReference val = dictionary.get(key);
if (val != null)
return val;
val = new MethodReference(key);
dictionary.put(key, val);
return val;
}
/**
* Find or create the canonical MethodReference instance for the given tuple.
*
* @param tref the type reference
* @param selector the selector for the method
* @throws IllegalArgumentException if selector is null
*/
public static synchronized MethodReference findOrCreate(TypeReference tref, Selector selector) {
if (selector == null) {
throw new IllegalArgumentException("selector is null");
}
return findOrCreate(tref, selector.getName(), selector.getDescriptor());
}
public static MethodReference findOrCreate(TypeReference t, String methodName, String descriptor) throws IllegalArgumentException {
return findOrCreate(Language.JAVA, t, methodName, descriptor);
}
public static MethodReference findOrCreate(Language l, TypeReference t, String methodName, String descriptor) throws IllegalArgumentException {
Descriptor d = Descriptor.findOrCreateUTF8(l, descriptor);
return findOrCreate(t, Atom.findOrCreateUnicodeAtom(methodName), d);
}
public static MethodReference findOrCreate(ClassLoaderReference loader, String methodClass, String methodName,
String methodSignature) throws IllegalArgumentException {
return findOrCreate(Language.JAVA, loader, methodClass, methodName, methodSignature);
}
public static MethodReference findOrCreate(Language l, ClassLoaderReference loader, String methodClass, String methodName,
String methodSignature) throws IllegalArgumentException {
TypeReference t = ShrikeUtil.makeTypeReference(loader, methodClass);
Atom name = Atom.findOrCreateUnicodeAtom(methodName);
Descriptor d = Descriptor.findOrCreateUTF8(l, methodSignature);
return findOrCreate(t, name, d);
}
/**
* @return the descriptor component of this member reference
*/
public final Descriptor getDescriptor() {
return selector.getDescriptor();
}
@Override
public final String toString() {
return "< " + getDeclaringClass().getClassLoader().getName() + ", " + getDeclaringClass().getName() + ", " + selector + " >";
}
MethodReference(Key key) {
super(key.type, key.name, key.hashCode());
selector = new Selector(key.name, key.descriptor);
TypeName[] parameterNames = key.descriptor.getParameters();
if (parameterNames != null) {
parameterTypes = new TypeReference[parameterNames.length];
} else {
parameterTypes = null;
}
ClassLoaderReference loader = getDeclaringClass().getClassLoader();
if (parameterNames != null) {
for (int i = 0; i < parameterNames.length; i++) {
parameterTypes[i] = TypeReference.findOrCreate(loader, parameterNames[i]);
}
}
TypeName r = key.descriptor.getReturnType();
returnType = TypeReference.findOrCreate(getDeclaringClass().getClassLoader(), r);
}
/**
* @return return type of the method
*/
public final TypeReference getReturnType() {
return returnType;
}
/**
* @return ith parameter to the method. This does NOT include the implicit "this" pointer.
*/
public final TypeReference getParameterType(int i) throws IllegalArgumentException {
if (parameterTypes == null || i >= parameterTypes.length) {
throw new IllegalArgumentException("illegal parameter number " + i + " for " + this);
}
return parameterTypes[i];
}
public boolean isInit() {
return getName().equals(MethodReference.initAtom);
}
/**
* @return something like: com.foo.bar.createLargeOrder(IILjava/lang/String;Ljava/sql/Date;)Ljava/lang/Integer;
*/
@Override
public String getSignature() {
// TODO: check that we're not calling this often.
String s = getDeclaringClass().getName().toString().substring(1).replace('/', '.') + "." + getName() + getDescriptor();
return s;
}
/**
* @return something like: createLargeOrder(IILjava.lang.String;SLjava.sql.Date;)Ljava.lang.Integer;
*/
public Selector getSelector() {
return selector;
}
/**
* This method does NOT include the implicit "this" parameter
*/
public int getNumberOfParameters() {
return parameterTypes == null ? 0 : parameterTypes.length;
}
/**
* An identifier/selector for methods.
*/
protected static class Key {
private final TypeReference type;
private final Atom name;
private final Descriptor descriptor;
Key(TypeReference type, Atom name, Descriptor descriptor) {
this.type = type;
this.name = name;
this.descriptor = descriptor;
}
@Override
public final int hashCode() {
return 7001 * type.hashCode() + 7013 * name.hashCode() + descriptor.hashCode();
}
@Override
public final boolean equals(Object other) {
assert other != null && this.getClass().equals(other.getClass());
Key that = (Key) other;
return type.equals(that.type) && name.equals(that.name) && descriptor.equals(that.descriptor);
}
}
}