* Signatures obtained from parsing source (".java") files differ subtly from * ones obtained from pre-compiled binary (".class") files in class names are * usually left unresolved in the former. For example, the normal resolved form * of the type "String" embeds the class's package name ("Ljava.lang.String;" * or "Ljava/lang/String;"), whereas the unresolved form contains only what is * written "QString;". *
*
* Generic types introduce to the Java language in J2SE 1.5 add three new
* facets to signatures: type variables, parameterized types with type arguments,
* and formal type parameters.
* The syntax for a type signature is: *
* TypeSignature ::= * "B" // byte * | "C" // char * | "D" // double * | "F" // float * | "I" // int * | "J" // long * | "S" // short * | "V" // void * | "Z" // boolean * | "T" + Identifier + ";" // type variable * | "[" + TypeSignature // array X[] * | ResolvedClassTypeSignature * | UnresolvedClassTypeSignature * * ResolvedClassTypeSignature ::= // resolved named type (in compiled code) * "L" + Identifier + OptionalTypeArguments * ( ( "." | "/" ) + Identifier + OptionalTypeArguments )* + ";" * * UnresolvedClassTypeSignature ::= // unresolved named type (in source code) * "Q" + Identifier + OptionalTypeArguments * ( ( "." | "/" ) + Identifier + OptionalTypeArguments )* + ";" * * OptionalTypeArguments ::= * "<" + TypeArgument+ + ">" * | * * TypeArgument ::= * | TypeSignature * | "*" // wildcard ? * | "+" TypeSignature // wildcard ? extends X * | "-" TypeSignature // wildcard ? super X ** *
* Examples: *
"[[I" denotes int[][]"Ljava.lang.String;" denotes java.lang.String in compiled code"QString;" denotes String in source code"Qjava.lang.String;" denotes java.lang.String in source code"[QString;" denotes String[] in source code"QMap<QString;*>;" denotes Map<String,?> in source code"Qjava.util.List<TV;>;" denotes java.util.List<V> in source code* The syntax for a method signature is: *
* MethodSignature ::= "(" + ParamTypeSignature* + ")" + ReturnTypeSignature
* ParamTypeSignature ::= TypeSignature
* ReturnTypeSignature ::= TypeSignature
*
* * Examples: *
"()I" denotes int foo()"([Ljava.lang.String;)V" denotes void foo(java.lang.String[]) in compiled code"(QString;)QObject;" denotes Object foo(String) in source code* The syntax for a formal type parameter signature is: *
* FormalTypeParameterSignature ::= * TypeVariableName + OptionalClassBound + InterfaceBound* * TypeVariableName ::= Identifier * OptionalClassBound ::= * ":" * | ":" + TypeSignature * InterfaceBound ::= * ":" + TypeSignature **
* Examples: *
"X:" denotes X"X:QReader;" denotes X extends Reader in source code"X:QReader;:QSerializable;" denotes X extends Reader & Serializable in source code* This class provides static methods and constants only; it is not intended to be * instantiated or subclassed by clients. *
*/ public final class Signature { /** * Character constant indicating the primitive type boolean in a signature. * Value is'Z'.
*/
public static final char C_BOOLEAN = 'Z';
/**
* Character constant indicating the primitive type byte in a signature.
* Value is 'B'.
*/
public static final char C_BYTE = 'B';
/**
* Character constant indicating the primitive type char in a signature.
* Value is 'C'.
*/
public static final char C_CHAR = 'C';
/**
* Character constant indicating the primitive type double in a signature.
* Value is 'D'.
*/
public static final char C_DOUBLE = 'D';
/**
* Character constant indicating the primitive type float in a signature.
* Value is 'F'.
*/
public static final char C_FLOAT = 'F';
/**
* Character constant indicating the primitive type int in a signature.
* Value is 'I'.
*/
public static final char C_INT = 'I';
/**
* Character constant indicating the semicolon in a signature.
* Value is ';'.
*/
public static final char C_SEMICOLON = ';';
/**
* Character constant indicating the colon in a signature.
* Value is ':'.
* @since 3.0
*/
public static final char C_COLON = ':';
/**
* Character constant indicating the primitive type long in a signature.
* Value is 'J'.
*/
public static final char C_LONG = 'J';
/**
* Character constant indicating the primitive type short in a signature.
* Value is 'S'.
*/
public static final char C_SHORT = 'S';
/**
* Character constant indicating result type void in a signature.
* Value is 'V'.
*/
public static final char C_VOID = 'V';
/**
* Character constant indicating the start of a resolved type variable in a
* signature. Value is 'T'.
* @since 3.0
*/
public static final char C_TYPE_VARIABLE = 'T';
/**
* Character constant indicating an unbound wildcard type argument
* in a signature.
* Value is '*'.
* @since 3.0
*/
public static final char C_STAR = '*';
/**
* Character constant indicating a bound wildcard type argument
* in a signature with extends clause.
* Value is '+'.
* @since 3.1
*/
public static final char C_EXTENDS = '+';
/**
* Character constant indicating a bound wildcard type argument
* in a signature with super clause.
* Value is '-'.
* @since 3.1
*/
public static final char C_SUPER = '-';
/**
* Character constant indicating the dot in a signature.
* Value is '.'.
*/
public static final char C_DOT = '.';
/**
* Character constant indicating the dollar in a signature.
* Value is '$'.
*/
public static final char C_DOLLAR = '$';
/**
* Character constant indicating an array type in a signature.
* Value is '['.
*/
public static final char C_ARRAY = '[';
/**
* Character constant indicating the start of a resolved, named type in a
* signature. Value is 'L'.
*/
public static final char C_RESOLVED = 'L';
/**
* Character constant indicating the start of an unresolved, named type in a
* signature. Value is 'Q'.
*/
public static final char C_UNRESOLVED = 'Q';
/**
* Character constant indicating the end of a named type in a signature.
* Value is ';'.
*/
public static final char C_NAME_END = ';';
/**
* Character constant indicating the start of a parameter type list in a
* signature. Value is '('.
*/
public static final char C_PARAM_START = '(';
/**
* Character constant indicating the end of a parameter type list in a
* signature. Value is ')'.
*/
public static final char C_PARAM_END = ')';
/**
* Character constant indicating the start of a formal type parameter
* (or type argument) list in a signature. Value is '<'.
* @since 3.0
*/
public static final char C_GENERIC_START = '<';
/**
* Character constant indicating the end of a generic type list in a
* signature. Value is '%gt;'.
* @since 3.0
*/
public static final char C_GENERIC_END = '>';
/**
* String constant for the signature of the primitive type boolean.
* Value is "Z".
*/
public static final String SIG_BOOLEAN = "Z"; //$NON-NLS-1$
/**
* String constant for the signature of the primitive type byte.
* Value is "B".
*/
public static final String SIG_BYTE = "B"; //$NON-NLS-1$
/**
* String constant for the signature of the primitive type char.
* Value is "C".
*/
public static final String SIG_CHAR = "C"; //$NON-NLS-1$
/**
* String constant for the signature of the primitive type double.
* Value is "D".
*/
public static final String SIG_DOUBLE = "D"; //$NON-NLS-1$
/**
* String constant for the signature of the primitive type float.
* Value is "F".
*/
public static final String SIG_FLOAT = "F"; //$NON-NLS-1$
/**
* String constant for the signature of the primitive type int.
* Value is "I".
*/
public static final String SIG_INT = "I"; //$NON-NLS-1$
/**
* String constant for the signature of the primitive type long.
* Value is "J".
*/
public static final String SIG_LONG = "J"; //$NON-NLS-1$
/**
* String constant for the signature of the primitive type short.
* Value is "S".
*/
public static final String SIG_SHORT = "S"; //$NON-NLS-1$
/** String constant for the signature of result type void.
* Value is "V".
*/
public static final String SIG_VOID = "V"; //$NON-NLS-1$
/**
* Kind constant for a class type signature.
* @see #getTypeSignatureKind(String)
* @since 3.0
*/
public static int CLASS_TYPE_SIGNATURE = 1;
/**
* Kind constant for a base (primitive or void) type signature.
* @see #getTypeSignatureKind(String)
* @since 3.0
*/
public static int BASE_TYPE_SIGNATURE = 2;
/**
* Kind constant for a type variable signature.
* @see #getTypeSignatureKind(String)
* @since 3.0
*/
public static int TYPE_VARIABLE_SIGNATURE = 3;
/**
* Kind constant for an array type signature.
* @see #getTypeSignatureKind(String)
* @since 3.0
*/
public static int ARRAY_TYPE_SIGNATURE = 4;
private static final char[] BOOLEAN = "boolean".toCharArray(); //$NON-NLS-1$
private static final char[] BYTE = "byte".toCharArray(); //$NON-NLS-1$
private static final char[] CHAR = "char".toCharArray(); //$NON-NLS-1$
private static final char[] DOUBLE = "double".toCharArray(); //$NON-NLS-1$
private static final char[] FLOAT = "float".toCharArray(); //$NON-NLS-1$
private static final char[] INT = "int".toCharArray(); //$NON-NLS-1$
private static final char[] LONG = "long".toCharArray(); //$NON-NLS-1$
private static final char[] SHORT = "short".toCharArray(); //$NON-NLS-1$
private static final char[] VOID = "void".toCharArray(); //$NON-NLS-1$
private static final char[] EXTENDS = "extends".toCharArray(); //$NON-NLS-1$
private static final char[] SUPER = "super".toCharArray(); //$NON-NLS-1$
private static final String EMPTY = new String(CharOperation.NO_CHAR);
private Signature() {
// Not instantiable
}
private static int checkName(char[] name, char[] typeName, int pos, int length) {
if (CharOperation.fragmentEquals(name, typeName, pos, true)) {
pos += name.length;
if (pos == length) return pos;
char currentChar = typeName[pos];
switch (currentChar) {
case ' ' :
case '.' :
case '<' :
case '>' :
case '[' :
case ',' :
return pos;
default:
if (Character.isWhitespace(currentChar))
return pos;
}
}
return -1;
}
/**
* Creates a new type signature with the given amount of array nesting added
* to the given type signature.
*
* @param typeSignature the type signature
* @param arrayCount the desired number of levels of array nesting
* @return the encoded array type signature
*
* @since 2.0
*/
public static char[] createArraySignature(char[] typeSignature, int arrayCount) {
if (arrayCount == 0) return typeSignature;
int sigLength = typeSignature.length;
char[] result = new char[arrayCount + sigLength];
for (int i = 0; i < arrayCount; i++) {
result[i] = C_ARRAY;
}
System.arraycopy(typeSignature, 0, result, arrayCount, sigLength);
return result;
}
/**
* Creates a new type signature with the given amount of array nesting added
* to the given type signature.
*
* @param typeSignature the type signature
* @param arrayCount the desired number of levels of array nesting
* @return the encoded array type signature
*/
public static String createArraySignature(String typeSignature, int arrayCount) {
return new String(createArraySignature(typeSignature.toCharArray(), arrayCount));
}
/**
* Creates a method signature from the given parameter and return type
* signatures. The encoded method signature is dot-based.
*
* @param parameterTypes the list of parameter type signatures
* @param returnType the return type signature
* @return the encoded method signature
*
* @since 2.0
*/
public static char[] createMethodSignature(char[][] parameterTypes, char[] returnType) {
int parameterTypesLength = parameterTypes.length;
int parameterLength = 0;
for (int i = 0; i < parameterTypesLength; i++) {
parameterLength += parameterTypes[i].length;
}
int returnTypeLength = returnType.length;
char[] result = new char[1 + parameterLength + 1 + returnTypeLength];
result[0] = C_PARAM_START;
int index = 1;
for (int i = 0; i < parameterTypesLength; i++) {
char[] parameterType = parameterTypes[i];
int length = parameterType.length;
System.arraycopy(parameterType, 0, result, index, length);
index += length;
}
result[index] = C_PARAM_END;
System.arraycopy(returnType, 0, result, index+1, returnTypeLength);
return result;
}
/**
* Creates a method signature from the given parameter and return type
* signatures. The encoded method signature is dot-based. This method
* is equivalent to
* createMethodSignature(parameterTypes, returnType).
*
* @param parameterTypes the list of parameter type signatures
* @param returnType the return type signature
* @return the encoded method signature
* @see Signature#createMethodSignature(char[][], char[])
*/
public static String createMethodSignature(String[] parameterTypes, String returnType) {
int parameterTypesLenth = parameterTypes.length;
char[][] parameters = new char[parameterTypesLenth][];
for (int i = 0; i < parameterTypesLenth; i++) {
parameters[i] = parameterTypes[i].toCharArray();
}
return new String(createMethodSignature(parameters, returnType.toCharArray()));
}
/**
* Creates a new type parameter signature with the given name and bounds.
*
* @param typeParameterName the type parameter name
* @param boundSignatures the signatures of associated bounds or empty array if none
* @return the encoded type parameter signature
*
* @since 3.1
*/
public static char[] createTypeParameterSignature(char[] typeParameterName, char[][] boundSignatures) {
int length = boundSignatures.length;
if (length == 0) {
return CharOperation.append(typeParameterName, C_COLON); // param signature with no bounds still gets trailing colon
}
int boundsSize = 0;
for (int i = 0; i < length; i++) {
boundsSize += boundSignatures[i].length + 1;
}
int nameLength = typeParameterName.length;
char[] result = new char[nameLength + boundsSize];
System.arraycopy(typeParameterName, 0, result, 0, nameLength);
int index = nameLength;
for (int i = 0; i < length; i++) {
result[index++] = C_COLON;
int boundLength = boundSignatures[i].length;
System.arraycopy(boundSignatures[i], 0, result, index, boundLength);
index += boundLength;
}
return result;
}
/**
* Creates a new type parameter signature with the given name and bounds.
*
* @param typeParameterName the type parameter name
* @param boundSignatures the signatures of associated bounds or empty array if none
* @return the encoded type parameter signature
*
* @since 3.1
*/
public static String createTypeParameterSignature(String typeParameterName, String[] boundSignatures) {
int length = boundSignatures.length;
char[][] boundSignatureChars = new char[length][];
for (int i = 0; i < length; i++) {
boundSignatureChars[i] = boundSignatures[i].toCharArray();
}
return new String(createTypeParameterSignature(typeParameterName.toCharArray(), boundSignatureChars));
}
/**
* Creates a new type signature from the given type name encoded as a character
* array. The type name may contain primitive types, array types or parameterized types.
* This method is equivalent to
* createTypeSignature(new String(typeName),isResolved), although
* more efficient for callers with character arrays rather than strings. If the
* type name is qualified, then it is expected to be dot-based.
*
* @param typeName the possibly qualified type name
* @param isResolved true if the type name is to be considered
* resolved (for example, a type name from a binary class file), and
* false if the type name is to be considered unresolved
* (for example, a type name found in source code)
* @return the encoded type signature
* @see #createTypeSignature(java.lang.String,boolean)
*/
public static String createTypeSignature(char[] typeName, boolean isResolved) {
return new String(createCharArrayTypeSignature(typeName, isResolved));
}
/**
* Creates a new type signature from the given type name encoded as a character
* array. The type name may contain primitive types or array types or parameterized types.
* This method is equivalent to
* createTypeSignature(new String(typeName),isResolved).toCharArray(),
* although more efficient for callers with character arrays rather than strings.
* If the type name is qualified, then it is expected to be dot-based.
*
* @param typeName the possibly qualified type name
* @param isResolved true if the type name is to be considered
* resolved (for example, a type name from a binary class file), and
* false if the type name is to be considered unresolved
* (for example, a type name found in source code)
* @return the encoded type signature
* @see #createTypeSignature(java.lang.String,boolean)
*
* @since 2.0
*/
public static char[] createCharArrayTypeSignature(char[] typeName, boolean isResolved) {
if (typeName == null) throw new IllegalArgumentException("null"); //$NON-NLS-1$
int length = typeName.length;
if (length == 0) throw new IllegalArgumentException(new String(typeName));
StringBuffer buffer = new StringBuffer(5);
int pos = encodeTypeSignature(typeName, 0, isResolved, length, buffer);
pos = consumeWhitespace(typeName, pos, length);
if (pos < length) throw new IllegalArgumentException(new String(typeName));
char[] result = new char[length = buffer.length()];
buffer.getChars(0, length, result, 0);
return result;
}
private static int consumeWhitespace(char[] typeName, int pos, int length) {
while (pos < length) {
char currentChar = typeName[pos];
if (currentChar != ' ' && !CharOperation.isWhitespace(currentChar)) {
break;
}
pos++;
}
return pos;
}
private static int encodeQualifiedName(char[] typeName, int pos, int length, StringBuffer buffer) {
int count = 0;
char lastAppendedChar = 0;
nameLoop: while (pos < length) {
char currentChar = typeName[pos];
switch (currentChar) {
case '<' :
case '>' :
case '[' :
case ',' :
break nameLoop;
case '.' :
buffer.append(C_DOT);
lastAppendedChar = C_DOT;
count++;
break;
default:
if (currentChar == ' ' || Character.isWhitespace(currentChar)) {
if (lastAppendedChar == C_DOT) { // allow spaces after a dot
pos = consumeWhitespace(typeName, pos, length) - 1; // will be incremented
break;
}
// allow spaces before a dot
int checkPos = checkNextChar(typeName, '.', pos, length, true);
if (checkPos > 0) {
buffer.append(C_DOT); // process dot immediately to avoid one iteration
lastAppendedChar = C_DOT;
count++;
pos = checkPos;
break;
}
break nameLoop;
}
buffer.append(currentChar);
lastAppendedChar = currentChar;
count++;
break;
}
pos++;
}
if (count == 0) throw new IllegalArgumentException(new String(typeName));
return pos;
}
private static int encodeArrayDimension(char[] typeName, int pos, int length, StringBuffer buffer) {
int checkPos;
while (pos < length && (checkPos = checkNextChar(typeName, '[', pos, length, true)) > 0) {
pos = checkNextChar(typeName, ']', checkPos, length, false);
buffer.append(C_ARRAY);
}
return pos;
}
private static int checkArrayDimension(char[] typeName, int pos, int length) {
int genericBalance = 0;
while (pos < length) {
switch(typeName[pos]) {
case '<' :
genericBalance++;
break;
case ',' :
if (genericBalance == 0) return -1;
break;
case '>':
if (genericBalance == 0) return -1;
genericBalance--;
break;
case '[':
if (genericBalance == 0) {
return pos;
}
}
pos++;
}
return -1;
}
private static int checkNextChar(char[] typeName, char expectedChar, int pos, int length, boolean isOptional) {
pos = consumeWhitespace(typeName, pos, length);
if (pos < length && typeName[pos] == expectedChar)
return pos + 1;
if (!isOptional) throw new IllegalArgumentException(new String(typeName));
return -1;
}
private static int encodeTypeSignature(char[] typeName, int start, boolean isResolved, int length, StringBuffer buffer) {
int pos = start;
pos = consumeWhitespace(typeName, pos, length);
if (pos >= length) throw new IllegalArgumentException(new String(typeName));
int checkPos;
char currentChar = typeName[pos];
switch (currentChar) {
// primitive type?
case 'b' :
checkPos = checkName(BOOLEAN, typeName, pos, length);
if (checkPos > 0) {
pos = encodeArrayDimension(typeName, checkPos, length, buffer);
buffer.append(C_BOOLEAN);
return pos;
}
checkPos = checkName(BYTE, typeName, pos, length);
if (checkPos > 0) {
pos = encodeArrayDimension(typeName, checkPos, length, buffer);
buffer.append(C_BYTE);
return pos;
}
break;
case 'c':
checkPos = checkName(CHAR, typeName, pos, length);
if (checkPos > 0) {
pos = encodeArrayDimension(typeName, checkPos, length, buffer);
buffer.append(C_CHAR);
return pos;
}
break;
case 'd':
checkPos = checkName(DOUBLE, typeName, pos, length);
if (checkPos > 0) {
pos = encodeArrayDimension(typeName, checkPos, length, buffer);
buffer.append(C_DOUBLE);
return pos;
}
break;
case 'f':
checkPos = checkName(FLOAT, typeName, pos, length);
if (checkPos > 0) {
pos = encodeArrayDimension(typeName, checkPos, length, buffer);
buffer.append(C_FLOAT);
return pos;
}
break;
case 'i':
checkPos = checkName(INT, typeName, pos, length);
if (checkPos > 0) {
pos = encodeArrayDimension(typeName, checkPos, length, buffer);
buffer.append(C_INT);
return pos;
}
break;
case 'l':
checkPos = checkName(LONG, typeName, pos, length);
if (checkPos > 0) {
pos = encodeArrayDimension(typeName, checkPos, length, buffer);
buffer.append(C_LONG);
return pos;
}
break;
case 's':
checkPos = checkName(SHORT, typeName, pos, length);
if (checkPos > 0) {
pos = encodeArrayDimension(typeName, checkPos, length, buffer);
buffer.append(C_SHORT);
return pos;
}
break;
case 'v':
checkPos = checkName(VOID, typeName, pos, length);
if (checkPos > 0) {
pos = encodeArrayDimension(typeName, checkPos, length, buffer);
buffer.append(C_VOID);
return pos;
}
break;
case '?':
// wildcard
pos = consumeWhitespace(typeName, pos+1, length);
checkPos = checkName(EXTENDS, typeName, pos, length);
if (checkPos > 0) {
buffer.append(C_EXTENDS);
pos = encodeTypeSignature(typeName, checkPos, isResolved, length, buffer);
return pos;
}
checkPos = checkName(SUPER, typeName, pos, length);
if (checkPos > 0) {
buffer.append(C_SUPER);
pos = encodeTypeSignature(typeName, checkPos, isResolved, length, buffer);
return pos;
}
buffer.append(C_STAR);
return pos;
}
// non primitive type
checkPos = checkArrayDimension(typeName, pos, length);
int end;
if (checkPos > 0) {
end = encodeArrayDimension(typeName, checkPos, length, buffer);
} else {
end = -1;
}
buffer.append(isResolved ? C_RESOLVED : C_UNRESOLVED);
while (true) { // loop on qualifiedName[* For example: *
*
* createTypeSignature("int", hucairz) -> "I"
* createTypeSignature("java.lang.String", true) -> "Ljava.lang.String;"
* createTypeSignature("String", false) -> "QString;"
* createTypeSignature("java.lang.String", false) -> "Qjava.lang.String;"
* createTypeSignature("int []", false) -> "[I"
*
*
*
*
* @param typeName the possibly qualified type name
* @param isResolved true if the type name is to be considered
* resolved (for example, a type name from a binary class file), and
* false if the type name is to be considered unresolved
* (for example, a type name found in source code)
* @return the encoded type signature
*/
public static String createTypeSignature(String typeName, boolean isResolved) {
return createTypeSignature(typeName == null ? null : typeName.toCharArray(), isResolved);
}
/**
* Returns the array count (array nesting depth) of the given type signature.
*
* @param typeSignature the type signature
* @return the array nesting depth, or 0 if not an array
* @exception IllegalArgumentException if the signature is not syntactically
* correct
*
* @since 2.0
*/
public static int getArrayCount(char[] typeSignature) throws IllegalArgumentException {
try {
int count = 0;
while (typeSignature[count] == C_ARRAY) {
++count;
}
return count;
} catch (ArrayIndexOutOfBoundsException e) { // signature is syntactically incorrect if last character is C_ARRAY
throw new IllegalArgumentException();
}
}
/**
* Returns the array count (array nesting depth) of the given type signature.
*
* @param typeSignature the type signature
* @return the array nesting depth, or 0 if not an array
* @exception IllegalArgumentException if the signature is not syntactically
* correct
*/
public static int getArrayCount(String typeSignature) throws IllegalArgumentException {
return getArrayCount(typeSignature.toCharArray());
}
/**
* Returns the type signature without any array nesting.
* * For example: *
*
* getElementType({'[', '[', 'I'}) --> {'I'}.
*
*
*
*
* @param typeSignature the type signature
* @return the type signature without arrays
* @exception IllegalArgumentException if the signature is not syntactically
* correct
*
* @since 2.0
*/
public static char[] getElementType(char[] typeSignature) throws IllegalArgumentException {
int count = getArrayCount(typeSignature);
if (count == 0) return typeSignature;
int length = typeSignature.length;
char[] result = new char[length-count];
System.arraycopy(typeSignature, count, result, 0, length-count);
return result;
}
/**
* Returns the type signature without any array nesting.
* * For example: *
*
* getElementType("[[I") --> "I".
*
*
*
*
* @param typeSignature the type signature
* @return the type signature without arrays
* @exception IllegalArgumentException if the signature is not syntactically
* correct
*/
public static String getElementType(String typeSignature) throws IllegalArgumentException {
return new String(getElementType(typeSignature.toCharArray()));
}
/**
* Returns the number of parameter types in the given method signature.
*
* @param methodSignature the method signature
* @return the number of parameters
* @exception IllegalArgumentException if the signature is not syntactically
* correct
* @since 2.0
*/
public static int getParameterCount(char[] methodSignature) throws IllegalArgumentException {
try {
int count = 0;
int i = CharOperation.indexOf(C_PARAM_START, methodSignature);
if (i < 0) {
throw new IllegalArgumentException();
} else {
i++;
}
for (;;) {
if (methodSignature[i] == C_PARAM_END) {
return count;
}
int e= scanTypeSignature(methodSignature, i);
if (e < 0) {
throw new IllegalArgumentException();
} else {
i = e + 1;
}
count++;
}
} catch (ArrayIndexOutOfBoundsException e) {
throw new IllegalArgumentException();
}
}
/**
* Returns the kind of type signature encoded by the given string.
*
* @param typeSignature the type signature string
* @return the kind of type signature; one of the kind constants:
* {@link #ARRAY_TYPE_SIGNATURE}, {@link #CLASS_TYPE_SIGNATURE},
* {@link #BASE_TYPE_SIGNATURE}, or {@link #TYPE_VARIABLE_SIGNATURE}
* @exception IllegalArgumentException if this is not a type signature
* @since 3.0
*/
public static int getTypeSignatureKind(char[] typeSignature) {
// need a minimum 1 char
if (typeSignature.length < 1) {
throw new IllegalArgumentException();
}
char c = typeSignature[0];
switch (c) {
case C_ARRAY :
return ARRAY_TYPE_SIGNATURE;
case C_RESOLVED :
case C_UNRESOLVED :
return CLASS_TYPE_SIGNATURE;
case C_TYPE_VARIABLE :
return TYPE_VARIABLE_SIGNATURE;
case C_BOOLEAN :
case C_BYTE :
case C_CHAR :
case C_DOUBLE :
case C_FLOAT :
case C_INT :
case C_LONG :
case C_SHORT :
case C_VOID :
return BASE_TYPE_SIGNATURE;
default :
throw new IllegalArgumentException();
}
}
/**
* Returns the kind of type signature encoded by the given string.
*
* @param typeSignature the type signature string
* @return the kind of type signature; one of the kind constants:
* {@link #ARRAY_TYPE_SIGNATURE}, {@link #CLASS_TYPE_SIGNATURE},
* {@link #BASE_TYPE_SIGNATURE}, or {@link #TYPE_VARIABLE_SIGNATURE}
* @exception IllegalArgumentException if this is not a type signature
* @since 3.0
*/
public static int getTypeSignatureKind(String typeSignature) {
// need a minimum 1 char
if (typeSignature.length() < 1) {
throw new IllegalArgumentException();
}
char c = typeSignature.charAt(0);
switch (c) {
case C_ARRAY :
return ARRAY_TYPE_SIGNATURE;
case C_RESOLVED :
case C_UNRESOLVED :
return CLASS_TYPE_SIGNATURE;
case C_TYPE_VARIABLE :
return TYPE_VARIABLE_SIGNATURE;
case C_BOOLEAN :
case C_BYTE :
case C_CHAR :
case C_DOUBLE :
case C_FLOAT :
case C_INT :
case C_LONG :
case C_SHORT :
case C_VOID :
return BASE_TYPE_SIGNATURE;
default :
throw new IllegalArgumentException();
}
}
/**
* Scans the given string for a type signature starting at the given index
* and returns the index of the last character.
* * TypeSignature: * | BaseTypeSignature * | ArrayTypeSignature * | ClassTypeSignature * | TypeVariableSignature ** * @param string the signature string * @param start the 0-based character index of the first character * @return the 0-based character index of the last character * @exception IllegalArgumentException if this is not a type signature * @see #appendTypeSignature(char[], int, boolean, StringBuffer) */ private static int scanTypeSignature(char[] string, int start) { // need a minimum 1 char if (start >= string.length) { throw new IllegalArgumentException(); } char c = string[start]; switch (c) { case C_ARRAY : return scanArrayTypeSignature(string, start); case C_RESOLVED : case C_UNRESOLVED : return scanClassTypeSignature(string, start); case C_TYPE_VARIABLE : return scanTypeVariableSignature(string, start); case C_BOOLEAN : case C_BYTE : case C_CHAR : case C_DOUBLE : case C_FLOAT : case C_INT : case C_LONG : case C_SHORT : case C_VOID : return scanBaseTypeSignature(string, start); default : throw new IllegalArgumentException(); } } /** * Scans the given string for a base type signature starting at the given index * and returns the index of the last character. *
* BaseTypeSignature: * B | C | D | F | I * | J | S | V | Z ** Note that although the base type "V" is only allowed in method return types, * there is no syntactic ambiguity. This method will accept them anywhere * without complaint. * * @param string the signature string * @param start the 0-based character index of the first character * @return the 0-based character index of the last character * @exception IllegalArgumentException if this is not a base type signature */ private static int scanBaseTypeSignature(char[] string, int start) { // need a minimum 1 char if (start >= string.length) { throw new IllegalArgumentException(); } char c = string[start]; if ("BCDFIJSVZ".indexOf(c) >= 0) { //$NON-NLS-1$ return start; } else { throw new IllegalArgumentException(); } } /** * Scans the given string for an array type signature starting at the given * index and returns the index of the last character. *
* ArrayTypeSignature: * [ TypeSignature ** * @param string the signature string * @param start the 0-based character index of the first character * @return the 0-based character index of the last character * @exception IllegalArgumentException if this is not an array type signature * @see #appendArrayTypeSignature(char[], int, boolean, StringBuffer) */ private static int scanArrayTypeSignature(char[] string, int start) { // need a minimum 2 char if (start >= string.length - 1) { throw new IllegalArgumentException(); } char c = string[start]; if (c != C_ARRAY) { //$NON-NLS-1$ throw new IllegalArgumentException(); } return scanTypeSignature(string, start + 1); } /** * Scans the given string for a type variable signature starting at the given * index and returns the index of the last character. *
* TypeVariableSignature: * T Identifier ; ** * @param string the signature string * @param start the 0-based character index of the first character * @return the 0-based character index of the last character * @exception IllegalArgumentException if this is not a type variable signature */ private static int scanTypeVariableSignature(char[] string, int start) { // need a minimum 3 chars "Tx;" if (start >= string.length - 2) { throw new IllegalArgumentException(); } // must start in "T" char c = string[start]; if (c != C_TYPE_VARIABLE) { throw new IllegalArgumentException(); } int id = scanIdentifier(string, start + 1); c = string[id + 1]; if (c == C_SEMICOLON) { return id + 1; } else { throw new IllegalArgumentException(); } } /** * Scans the given string for an identifier starting at the given * index and returns the index of the last character. * Stop characters are: ";", ":", "<", ">", "/", ".". * * @param string the signature string * @param start the 0-based character index of the first character * @return the 0-based character index of the last character * @exception IllegalArgumentException if this is not an identifier */ private static int scanIdentifier(char[] string, int start) { // need a minimum 1 char if (start >= string.length) { throw new IllegalArgumentException(); } int p = start; while (true) { char c = string[p]; if (c == '<' || c == '>' || c == ':' || c == ';' || c == '.' || c == '/') { return p - 1; } p++; if (p == string.length) { return p - 1; } } } /** * Scans the given string for a class type signature starting at the given * index and returns the index of the last character. *
* ClassTypeSignature:
* { L | Q } Identifier
* { { / | . Identifier [ < TypeArgumentSignature* > ] }
* ;
*
* Note that although all "/"-identifiers most come before "."-identifiers,
* there is no syntactic ambiguity. This method will accept them without
* complaint.
*
* @param string the signature string
* @param start the 0-based character index of the first character
* @return the 0-based character index of the last character
* @exception IllegalArgumentException if this is not a class type signature
* @see #appendClassTypeSignature(char[], int, boolean, StringBuffer)
*/
private static int scanClassTypeSignature(char[] string, int start) {
// need a minimum 3 chars "Lx;"
if (start >= string.length - 2) {
throw new IllegalArgumentException();
}
// must start in "L" or "Q"
char c = string[start];
if (c != C_RESOLVED && c != C_UNRESOLVED) {
return -1;
}
int p = start + 1;
while (true) {
if (p >= string.length) {
throw new IllegalArgumentException();
}
c = string[p];
if (c == C_SEMICOLON) {
// all done
return p;
} else if (c == C_GENERIC_START) {
int e = scanTypeArgumentSignatures(string, p);
p = e;
} else if (c == C_DOT || c == '/') {
int id = scanIdentifier(string, p + 1);
p = id;
}
p++;
}
}
/**
* Scans the given string for a list of type argument signatures starting at
* the given index and returns the index of the last character.
* * TypeArgumentSignatures: * < TypeArgumentSignature* > ** Note that although there is supposed to be at least one type argument, there * is no syntactic ambiguity if there are none. This method will accept zero * type argument signatures without complaint. * * @param string the signature string * @param start the 0-based character index of the first character * @return the 0-based character index of the last character * @exception IllegalArgumentException if this is not a list of type arguments * signatures * @see #appendTypeArgumentSignatures(char[], int, boolean, StringBuffer) */ private static int scanTypeArgumentSignatures(char[] string, int start) { // need a minimum 2 char "<>" if (start >= string.length - 1) { throw new IllegalArgumentException(); } char c = string[start]; if (c != C_GENERIC_START) { throw new IllegalArgumentException(); } int p = start + 1; while (true) { if (p >= string.length) { throw new IllegalArgumentException(); } c = string[p]; if (c == C_GENERIC_END) { return p; } int e = scanTypeArgumentSignature(string, p); p = e + 1; } } /** * Scans the given string for a type argument signature starting at the given * index and returns the index of the last character. *
* TypeArgumentSignature: * * * | + TypeSignature * | - TypeSignature * | TypeSignature ** Note that although base types are not allowed in type arguments, there is * no syntactic ambiguity. This method will accept them without complaint. * * @param string the signature string * @param start the 0-based character index of the first character * @return the 0-based character index of the last character * @exception IllegalArgumentException if this is not a type argument signature * @see #appendTypeArgumentSignature(char[], int, boolean, StringBuffer) */ private static int scanTypeArgumentSignature(char[] string, int start) { // need a minimum 1 char if (start >= string.length) { throw new IllegalArgumentException(); } char c = string[start]; if (c == C_STAR) { return start; } if (c == '+' || c == '-') { return scanTypeSignature(string, start + 1); } else { return scanTypeSignature(string, start); } } /** * Returns the number of parameter types in the given method signature. * * @param methodSignature the method signature * @return the number of parameters * @exception IllegalArgumentException if the signature is not syntactically * correct */ public static int getParameterCount(String methodSignature) throws IllegalArgumentException { return getParameterCount(methodSignature.toCharArray()); } /** * Extracts the parameter type signatures from the given method signature. * The method signature is expected to be dot-based. * * @param methodSignature the method signature * @return the list of parameter type signatures * @exception IllegalArgumentException if the signature is syntactically * incorrect * * @since 2.0 */ public static char[][] getParameterTypes(char[] methodSignature) throws IllegalArgumentException { try { int count = getParameterCount(methodSignature); char[][] result = new char[count][]; if (count == 0) { return result; } int i = CharOperation.indexOf(C_PARAM_START, methodSignature); if (i < 0) { throw new IllegalArgumentException(); } else { i++; } int t = 0; for (;;) { if (methodSignature[i] == C_PARAM_END) { return result; } int e = scanTypeSignature(methodSignature, i); if (e < 0) { throw new IllegalArgumentException(); } result[t] = CharOperation.subarray(methodSignature, i, e + 1); t++; i = e + 1; } } catch (ArrayIndexOutOfBoundsException e) { throw new IllegalArgumentException(); } } /** * Extracts the parameter type signatures from the given method signature. * The method signature is expected to be dot-based. * * @param methodSignature the method signature * @return the list of parameter type signatures * @exception IllegalArgumentException if the signature is syntactically * incorrect */ public static String[] getParameterTypes(String methodSignature) throws IllegalArgumentException { char[][] parameterTypes = getParameterTypes(methodSignature.toCharArray()); return CharOperation.toStrings(parameterTypes); } /** * Extracts the thrown exception type signatures from the given method signature if any * The method signature is expected to be dot-based. * * @param methodSignature the method signature * @return the list of thrown exception type signatures * @exception IllegalArgumentException if the signature is syntactically * incorrect */ public static String[] getThrownExceptionTypes(String methodSignature) throws IllegalArgumentException { char[][] parameterTypes = getThrownExceptionTypes(methodSignature.toCharArray()); return CharOperation.toStrings(parameterTypes); } /** * Extracts the thrown exception type signatures from the given method signature if any * The method signature is expected to be dot-based. * * @param methodSignature the method signature * @return the list of thrown exception type signatures * @exception IllegalArgumentException if the signature is syntactically * incorrect */ public static char[][] getThrownExceptionTypes(char[] methodSignature) throws IllegalArgumentException { // skip type parameters int paren = CharOperation.lastIndexOf(C_PARAM_END, methodSignature); if (paren == -1) { throw new IllegalArgumentException(); } // ignore return type int exceptionStart = scanTypeSignature(methodSignature, paren+1) + 1; int length = methodSignature.length; if (exceptionStart == length) return CharOperation.NO_CHAR_CHAR; ArrayList exceptionList = new ArrayList(1); int i = exceptionStart; while (i < length) { i = scanTypeSignature(methodSignature, i) + 1; exceptionList.add(CharOperation.subarray(methodSignature, exceptionStart,i)); exceptionStart = i; } char[][] result; exceptionList.toArray(result = new char[exceptionList.size()][]); return result; } /** * Extracts the type argument signatures from the given type signature. * Returns an empty array if the type signature is not a parameterized type signature. * * @param parameterizedTypeSignature the parameterized type signature * @return the signatures of the type arguments * @exception IllegalArgumentException if the signature is syntactically incorrect * * @since 3.1 */ public static char[][] getTypeArguments(char[] parameterizedTypeSignature) throws IllegalArgumentException { int length = parameterizedTypeSignature.length; if (length < 2 || parameterizedTypeSignature[length-2] != C_GENERIC_END) // cannot have type arguments otherwise signature would end by ">;" return CharOperation.NO_CHAR_CHAR; int count = 1; // start to count generic end/start peers int start = length - 2; while (start >= 0 && count > 0) { switch (parameterizedTypeSignature[--start]) { case C_GENERIC_START: count--; break; case C_GENERIC_END: count++; break; } } if (start < 0) // invalid number of generic start/end throw new IllegalArgumentException(); ArrayList args = new ArrayList(); int p = start + 1; while (true) { if (p >= parameterizedTypeSignature.length) { throw new IllegalArgumentException(); } char c = parameterizedTypeSignature[p]; if (c == C_GENERIC_END) { int size = args.size(); char[][] result = new char[size][]; args.toArray(result); return result; } int e = scanTypeArgumentSignature(parameterizedTypeSignature, p); args.add(CharOperation.subarray(parameterizedTypeSignature, p, e+1)); p = e + 1; } } /** * Extracts the type argument signatures from the given type signature. * Returns an empty array if the type signature is not a parameterized type signature. * * @param parameterizedTypeSignature the parameterized type signature * @return the signatures of the type arguments * @exception IllegalArgumentException if the signature is syntactically incorrect * * @since 3.1 */ public static String[] getTypeArguments(String parameterizedTypeSignature) throws IllegalArgumentException { char[][] args = getTypeArguments(parameterizedTypeSignature.toCharArray()); return CharOperation.toStrings(args); } /** * Extracts the type erasure signature from the given parameterized type signature. * Returns the given type signature if it is not parameterized. * * @param parameterizedTypeSignature the parameterized type signature * @return the signature of the type erasure * @exception IllegalArgumentException if the signature is syntactically * incorrect * * @since 3.1 */ public static char[] getTypeErasure(char[] parameterizedTypeSignature) throws IllegalArgumentException { int end = CharOperation.indexOf(C_GENERIC_START, parameterizedTypeSignature); if (end == -1) return parameterizedTypeSignature; int length = parameterizedTypeSignature.length; char[] result = new char[length]; int pos = 0; int start = 0; int deep= 0; for (int idx=end; idx
* For example: *
*
* getQualifier({'j', 'a', 'v', 'a', '.', 'l', 'a', 'n', 'g', '.', 'O', 'b', 'j', 'e', 'c', 't'}) -> {'j', 'a', 'v', 'a', '.', 'l', 'a', 'n', 'g'}
* getQualifier({'O', 'u', 't', 'e', 'r', '.', 'I', 'n', 'n', 'e', 'r'}) -> {'O', 'u', 't', 'e', 'r'}
* getQualifier({'j', 'a', 'v', 'a', '.', 'u', 't', 'i', 'l', '.', 'L', 'i', 's', 't', '<', 'j', 'a', 'v', 'a', '.', 'l', 'a', 'n', 'g', '.', 'S', 't', 'r', 'i', 'n', 'g', '>'}) -> {'j', 'a', 'v', 'a', '.', 'u', 't', 'i', 'l'}
*
*
*
*
* @param name the name
* @return the qualifier prefix, or the empty char array if the name contains no
* dots
* @exception NullPointerException if name is null
* @since 2.0
*/
public static char[] getQualifier(char[] name) {
int firstGenericStart = CharOperation.indexOf(C_GENERIC_START, name);
int lastDot = CharOperation.lastIndexOf(C_DOT, name, 0, firstGenericStart == -1 ? name.length-1 : firstGenericStart);
if (lastDot == -1) {
return CharOperation.NO_CHAR;
}
return CharOperation.subarray(name, 0, lastDot);
}
/**
* Returns a string containing all but the last segment of the given
* dot-separated qualified name. Returns the empty string if it is not qualified.
* * For example: *
*
* getQualifier("java.lang.Object") -> "java.lang"
* getQualifier("Outer.Inner") -> "Outer"
* getQualifier("java.util.List") -> "java.util"
*
*
*
*
* @param name the name
* @return the qualifier prefix, or the empty string if the name contains no
* dots
* @exception NullPointerException if name is null
*/
public static String getQualifier(String name) {
char[] qualifier = getQualifier(name.toCharArray());
if (qualifier.length == 0) return EMPTY;
return new String(qualifier);
}
/**
* Extracts the return type from the given method signature. The method signature is
* expected to be dot-based.
*
* @param methodSignature the method signature
* @return the type signature of the return type
* @exception IllegalArgumentException if the signature is syntactically
* incorrect
*
* @since 2.0
*/
public static char[] getReturnType(char[] methodSignature) throws IllegalArgumentException {
// skip type parameters
int paren = CharOperation.lastIndexOf(C_PARAM_END, methodSignature);
if (paren == -1) {
throw new IllegalArgumentException();
}
// there could be thrown exceptions behind, thus scan one type exactly
int last = scanTypeSignature(methodSignature, paren+1);
return CharOperation.subarray(methodSignature, paren + 1, last+1);
}
/**
* Extracts the return type from the given method signature. The method signature is
* expected to be dot-based.
*
* @param methodSignature the method signature
* @return the type signature of the return type
* @exception IllegalArgumentException if the signature is syntactically
* incorrect
*/
public static String getReturnType(String methodSignature) throws IllegalArgumentException {
return new String(getReturnType(methodSignature.toCharArray()));
}
/**
* Returns package fragment of a type signature. The package fragment separator must be '.'
* and the type fragment separator must be '$'.
* * For example: *
*
* getSignatureQualifier({'L', 'j', 'a', 'v', 'a', '.', 'u', 't', 'i', 'l', '.', 'M', 'a', 'p', '$', 'E', 'n', 't', 'r', 'y', ';'}) -> {'j', 'a', 'v', 'a', '.', 'u', 't', 'i', 'l'}
*
*
*
*
* @param typeSignature the type signature
* @return the package fragment (separators are '.')
* @since 3.1
*/
public static char[] getSignatureQualifier(char[] typeSignature) {
if(typeSignature == null) return CharOperation.NO_CHAR;
char[] qualifiedType = Signature.toCharArray(typeSignature);
int dotCount = 0;
indexFound: for(int i = 0; i < typeSignature.length; i++) {
switch(typeSignature[i]) {
case C_DOT:
dotCount++;
break;
case C_GENERIC_START:
break indexFound;
case C_DOLLAR:
break indexFound;
}
}
if(dotCount > 0) {
for(int i = 0; i < qualifiedType.length; i++) {
if(qualifiedType[i] == '.') {
dotCount--;
}
if(dotCount <= 0) {
return CharOperation.subarray(qualifiedType, 0, i);
}
}
}
return CharOperation.NO_CHAR;
}
/**
* Returns package fragment of a type signature. The package fragment separator must be '.'
* and the type fragment separator must be '$'.
* * For example: *
*
* getSignatureQualifier("Ljava.util.Map$Entry") -> "java.util"
*
*
*
*
* @param typeSignature the type signature
* @return the package fragment (separators are '.')
* @since 3.1
*/
public static String getSignatureQualifier(String typeSignature) {
return new String(getSignatureQualifier(typeSignature == null ? null : typeSignature.toCharArray()));
}
/**
* Returns type fragment of a type signature. The package fragment separator must be '.'
* and the type fragment separator must be '$'.
* * For example: *
*
* getSignatureSimpleName({'L', 'j', 'a', 'v', 'a', '.', 'u', 't', 'i', 'l', '.', 'M', 'a', 'p', '$', 'E', 'n', 't', 'r', 'y', ';'}) -> {'M', 'a', 'p', '.', 'E', 'n', 't', 'r', 'y'}
*
*
*
*
* @param typeSignature the type signature
* @return the type fragment (separators are '.')
* @since 3.1
*/
public static char[] getSignatureSimpleName(char[] typeSignature) {
if(typeSignature == null) return CharOperation.NO_CHAR;
char[] qualifiedType = Signature.toCharArray(typeSignature);
int dotCount = 0;
indexFound: for(int i = 0; i < typeSignature.length; i++) {
switch(typeSignature[i]) {
case C_DOT:
dotCount++;
break;
case C_GENERIC_START:
break indexFound;
case C_DOLLAR:
break indexFound;
}
}
if(dotCount > 0) {
for(int i = 0; i < qualifiedType.length; i++) {
if(qualifiedType[i] == '.') {
dotCount--;
}
if(dotCount <= 0) {
return CharOperation.subarray(qualifiedType, i + 1, qualifiedType.length);
}
}
}
return qualifiedType;
}
/**
* Returns type fragment of a type signature. The package fragment separator must be '.'
* and the type fragment separator must be '$'.
* * For example: *
*
* getSignatureSimpleName("Ljava.util.Map$Entry") -> "Map.Entry"
*
*
*
*
* @param typeSignature the type signature
* @return the type fragment (separators are '.')
* @since 3.1
*/
public static String getSignatureSimpleName(String typeSignature) {
return new String(getSignatureSimpleName(typeSignature == null ? null : typeSignature.toCharArray()));
}
/**
* Returns the last segment of the given dot-separated qualified name.
* Returns the given name if it is not qualified.
* * For example: *
*
* getSimpleName({'j', 'a', 'v', 'a', '.', 'l', 'a', 'n', 'g', '.', 'O', 'b', 'j', 'e', 'c', 't'}) -> {'O', 'b', 'j', 'e', 'c', 't'}
*
*
*
*
* @param name the name
* @return the last segment of the qualified name
* @exception NullPointerException if name is null
* @since 2.0
*/
public static char[] getSimpleName(char[] name) {
int lastDot = -1, lastGenericStart = -1, lastGenericEnd = -1;
int depth = 0;
int length = name.length;
lastDotLookup: for (int i = length -1; i >= 0; i--) {
switch (name[i]) {
case '.':
if (depth == 0) {
lastDot = i;
break lastDotLookup;
}
break;
case '<':
depth--;
if (depth == 0) lastGenericStart = i;
break;
case '>':
if (depth == 0) lastGenericEnd = i;
depth++;
break;
}
}
if (lastGenericStart < 0) {
if (lastDot < 0) {
return name;
}
return CharOperation.subarray(name, lastDot + 1, length);
}
StringBuffer buffer = new StringBuffer(10);
int nameStart = lastDot < 0 ? 0 : lastDot+1;
buffer.append(name, nameStart, lastGenericStart - nameStart);
appendArgumentSimpleNames(name, lastGenericStart, lastGenericEnd, buffer);
buffer.append(name, lastGenericEnd+1, length-lastGenericEnd-1); // copy trailing portion, may contain dimensions
char[] result = new char[length = buffer.length()];
buffer.getChars(0, length, result, 0);
return result;
}
/**
* Returns the last segment of the given dot-separated qualified name.
* Returns the given name if it is not qualified.
* * For example: *