Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
org.eclipse.jdt.internal.compiler.classfmt.MethodInfo Maven / Gradle / Ivy
/*******************************************************************************
* Copyright (c) 2000, 2015 IBM Corporation and others.
* 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
* Stephan Herrmann - Contribution for bug 186342 - [compiler][null] Using annotations for null checking
* Jesper Steen Moeller - Contribution for bug 406973 - [compiler] Parse MethodParameters attribute
* Andy Clement (GoPivotal, Inc) [email protected] - Contributions for
* Bug 407191 - [1.8] Binary access support for type annotations
*******************************************************************************/
package org.eclipse.jdt.internal.compiler.classfmt;
import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.internal.compiler.codegen.AttributeNamesConstants;
import org.eclipse.jdt.internal.compiler.codegen.ConstantPool;
import org.eclipse.jdt.internal.compiler.env.IBinaryAnnotation;
import org.eclipse.jdt.internal.compiler.env.IBinaryMethod;
import org.eclipse.jdt.internal.compiler.env.IBinaryTypeAnnotation;
import org.eclipse.jdt.internal.compiler.util.Util;
@SuppressWarnings("rawtypes")
public class MethodInfo extends ClassFileStruct implements IBinaryMethod, Comparable {
static private final char[][] noException = CharOperation.NO_CHAR_CHAR;
static private final char[][] noArgumentNames = CharOperation.NO_CHAR_CHAR;
static private final char[] ARG = "arg".toCharArray(); //$NON-NLS-1$
protected int accessFlags;
protected int attributeBytes;
protected char[] descriptor;
protected char[][] exceptionNames;
protected char[] name;
protected char[] signature;
protected int signatureUtf8Offset;
protected long tagBits;
protected char[][] argumentNames;
public static MethodInfo createMethod(byte classFileBytes[], int offsets[], int offset) {
MethodInfo methodInfo = new MethodInfo(classFileBytes, offsets, offset);
int attributesCount = methodInfo.u2At(6);
int readOffset = 8;
AnnotationInfo[] annotations = null;
AnnotationInfo[][] parameterAnnotations = null;
TypeAnnotationInfo[] typeAnnotations = null;
for (int i = 0; i < attributesCount; i++) {
// check the name of each attribute
int utf8Offset = methodInfo.constantPoolOffsets[methodInfo.u2At(readOffset)] - methodInfo.structOffset;
char[] attributeName = methodInfo.utf8At(utf8Offset + 3, methodInfo.u2At(utf8Offset + 1));
if (attributeName.length > 0) {
switch(attributeName[0]) {
case 'M' :
if (CharOperation.equals(attributeName, AttributeNamesConstants.MethodParametersName)) {
methodInfo.decodeMethodParameters(readOffset, methodInfo);
}
break;
case 'S' :
if (CharOperation.equals(AttributeNamesConstants.SignatureName, attributeName))
methodInfo.signatureUtf8Offset = methodInfo.constantPoolOffsets[methodInfo.u2At(readOffset + 6)] - methodInfo.structOffset;
break;
case 'R' :
AnnotationInfo[] methodAnnotations = null;
AnnotationInfo[][] paramAnnotations = null;
TypeAnnotationInfo[] methodTypeAnnotations = null;
if (CharOperation.equals(attributeName, AttributeNamesConstants.RuntimeVisibleAnnotationsName)) {
methodAnnotations = decodeMethodAnnotations(readOffset, true, methodInfo);
} else if (CharOperation.equals(attributeName, AttributeNamesConstants.RuntimeInvisibleAnnotationsName)) {
methodAnnotations = decodeMethodAnnotations(readOffset, false, methodInfo);
} else if (CharOperation.equals(attributeName, AttributeNamesConstants.RuntimeVisibleParameterAnnotationsName)) {
paramAnnotations = decodeParamAnnotations(readOffset, true, methodInfo);
} else if (CharOperation.equals(attributeName, AttributeNamesConstants.RuntimeInvisibleParameterAnnotationsName)) {
paramAnnotations = decodeParamAnnotations(readOffset, false, methodInfo);
} else if (CharOperation.equals(attributeName, AttributeNamesConstants.RuntimeVisibleTypeAnnotationsName)) {
methodTypeAnnotations = decodeTypeAnnotations(readOffset, true, methodInfo);
} else if (CharOperation.equals(attributeName, AttributeNamesConstants.RuntimeInvisibleTypeAnnotationsName)) {
methodTypeAnnotations = decodeTypeAnnotations(readOffset, false, methodInfo);
}
if (methodAnnotations != null) {
if (annotations == null) {
annotations = methodAnnotations;
} else {
int length = annotations.length;
AnnotationInfo[] newAnnotations = new AnnotationInfo[length + methodAnnotations.length];
System.arraycopy(annotations, 0, newAnnotations, 0, length);
System.arraycopy(methodAnnotations, 0, newAnnotations, length, methodAnnotations.length);
annotations = newAnnotations;
}
} else if (paramAnnotations != null) {
int numberOfParameters = paramAnnotations.length;
if (parameterAnnotations == null) {
parameterAnnotations = paramAnnotations;
} else {
for (int p = 0; p < numberOfParameters; p++) {
int numberOfAnnotations = paramAnnotations[p] == null ? 0 : paramAnnotations[p].length;
if (numberOfAnnotations > 0) {
if (parameterAnnotations[p] == null) {
parameterAnnotations[p] = paramAnnotations[p];
} else {
int length = parameterAnnotations[p].length;
AnnotationInfo[] newAnnotations = new AnnotationInfo[length + numberOfAnnotations];
System.arraycopy(parameterAnnotations[p], 0, newAnnotations, 0, length);
System.arraycopy(paramAnnotations[p], 0, newAnnotations, length, numberOfAnnotations);
parameterAnnotations[p] = newAnnotations;
}
}
}
}
} else if (methodTypeAnnotations != null) {
if (typeAnnotations == null) {
typeAnnotations = methodTypeAnnotations;
} else {
int length = typeAnnotations.length;
TypeAnnotationInfo[] newAnnotations = new TypeAnnotationInfo[length + methodTypeAnnotations.length];
System.arraycopy(typeAnnotations, 0, newAnnotations, 0, length);
System.arraycopy(methodTypeAnnotations, 0, newAnnotations, length, methodTypeAnnotations.length);
typeAnnotations = newAnnotations;
}
}
break;
}
}
readOffset += (6 + methodInfo.u4At(readOffset + 2));
}
methodInfo.attributeBytes = readOffset;
if (typeAnnotations != null)
return new MethodInfoWithTypeAnnotations(methodInfo, annotations, parameterAnnotations, typeAnnotations);
if (parameterAnnotations != null)
return new MethodInfoWithParameterAnnotations(methodInfo, annotations, parameterAnnotations);
if (annotations != null)
return new MethodInfoWithAnnotations(methodInfo, annotations);
return methodInfo;
}
static AnnotationInfo[] decodeAnnotations(int offset, boolean runtimeVisible, int numberOfAnnotations, MethodInfo methodInfo) {
AnnotationInfo[] result = new AnnotationInfo[numberOfAnnotations];
int readOffset = offset;
for (int i = 0; i < numberOfAnnotations; i++) {
result[i] = new AnnotationInfo(methodInfo.reference, methodInfo.constantPoolOffsets,
readOffset + methodInfo.structOffset, runtimeVisible, false);
readOffset += result[i].readOffset;
}
return result;
}
static AnnotationInfo[] decodeMethodAnnotations(int offset, boolean runtimeVisible, MethodInfo methodInfo) {
int numberOfAnnotations = methodInfo.u2At(offset + 6);
if (numberOfAnnotations > 0) {
AnnotationInfo[] annos = decodeAnnotations(offset + 8, runtimeVisible, numberOfAnnotations, methodInfo);
if (runtimeVisible){
int numStandardAnnotations = 0;
for( int i=0; i 0) {
int readOffset = offset + 8;
TypeAnnotationInfo[] typeAnnos = new TypeAnnotationInfo[numberOfAnnotations];
for (int i = 0; i < numberOfAnnotations; i++) {
TypeAnnotationInfo newInfo = new TypeAnnotationInfo(methodInfo.reference, methodInfo.constantPoolOffsets, readOffset + methodInfo.structOffset, runtimeVisible, false);
readOffset += newInfo.readOffset;
typeAnnos[i] = newInfo;
}
return typeAnnos;
}
return null;
}
static AnnotationInfo[][] decodeParamAnnotations(int offset, boolean runtimeVisible, MethodInfo methodInfo) {
AnnotationInfo[][] allParamAnnotations = null;
int numberOfParameters = methodInfo.u1At(offset + 6);
if (numberOfParameters > 0) {
// u2 attribute_name_index + u4 attribute_length + u1 num_parameters
int readOffset = offset + 7;
for (int i=0 ; i < numberOfParameters; i++) {
int numberOfAnnotations = methodInfo.u2At(readOffset);
readOffset += 2;
if (numberOfAnnotations > 0) {
if (allParamAnnotations == null)
allParamAnnotations = new AnnotationInfo[numberOfParameters][];
AnnotationInfo[] annos = decodeAnnotations(readOffset, runtimeVisible, numberOfAnnotations, methodInfo);
allParamAnnotations[i] = annos;
for (int aIndex = 0; aIndex < annos.length; aIndex++)
readOffset += annos[aIndex].readOffset;
}
}
}
return allParamAnnotations;
}
/**
* @param classFileBytes byte[]
* @param offsets int[]
* @param offset int
*/
protected MethodInfo (byte classFileBytes[], int offsets[], int offset) {
super(classFileBytes, offsets, offset);
this.accessFlags = -1;
this.signatureUtf8Offset = -1;
}
public int compareTo(Object o) {
MethodInfo otherMethod = (MethodInfo) o;
int result = new String(getSelector()).compareTo(new String(otherMethod.getSelector()));
if (result != 0) return result;
return new String(getMethodDescriptor()).compareTo(new String(otherMethod.getMethodDescriptor()));
}
public boolean equals(Object o) {
if (!(o instanceof MethodInfo)) {
return false;
}
MethodInfo otherMethod = (MethodInfo) o;
return CharOperation.equals(getSelector(), otherMethod.getSelector())
&& CharOperation.equals(getMethodDescriptor(), otherMethod.getMethodDescriptor());
}
public int hashCode() {
return CharOperation.hashCode(getSelector()) + CharOperation.hashCode(getMethodDescriptor());
}
/**
* @return the annotations or null if there is none.
*/
public IBinaryAnnotation[] getAnnotations() {
return null;
}
/**
* @see org.eclipse.jdt.internal.compiler.env.IGenericMethod#getArgumentNames()
*/
public char[][] getArgumentNames() {
if (this.argumentNames == null) {
readCodeAttribute();
}
return this.argumentNames;
}
public Object getDefaultValue() {
return null;
}
/**
* Answer the resolved names of the exception types in the
* class file format as specified in section 4.2 of the Java 2 VM spec
* or null if the array is empty.
*
* For example, java.lang.String is java/lang/String.
* @return char[][]
*/
public char[][] getExceptionTypeNames() {
if (this.exceptionNames == null) {
readExceptionAttributes();
}
return this.exceptionNames;
}
public char[] getGenericSignature() {
if (this.signatureUtf8Offset != -1) {
if (this.signature == null) {
// decode the signature
this.signature = utf8At(this.signatureUtf8Offset + 3, u2At(this.signatureUtf8Offset + 1));
}
return this.signature;
}
return null;
}
/**
* Answer the receiver's method descriptor which describes the parameter &
* return types as specified in section 4.3.3 of the Java 2 VM spec.
*
* For example:
* - int foo(String) is (Ljava/lang/String;)I
* - void foo(Object[]) is (I)[Ljava/lang/Object;
* @return char[]
*/
public char[] getMethodDescriptor() {
if (this.descriptor == null) {
// read the name
int utf8Offset = this.constantPoolOffsets[u2At(4)] - this.structOffset;
this.descriptor = utf8At(utf8Offset + 3, u2At(utf8Offset + 1));
}
return this.descriptor;
}
/**
* Answer an int whose bits are set according the access constants
* defined by the VM spec.
* Set the AccDeprecated and AccSynthetic bits if necessary
* @return int
*/
public int getModifiers() {
if (this.accessFlags == -1) {
// compute the accessflag. Don't forget the deprecated attribute
this.accessFlags = u2At(0);
readModifierRelatedAttributes();
}
return this.accessFlags;
}
public IBinaryAnnotation[] getParameterAnnotations(int index, char[] classFileName) {
return null;
}
public int getAnnotatedParametersCount() {
return 0;
}
public IBinaryTypeAnnotation[] getTypeAnnotations() {
return null;
}
/**
* Answer the name of the method.
*
* For a constructor, answer & for a clinit method.
* @return char[]
*/
public char[] getSelector() {
if (this.name == null) {
// read the name
int utf8Offset = this.constantPoolOffsets[u2At(2)] - this.structOffset;
this.name = utf8At(utf8Offset + 3, u2At(utf8Offset + 1));
}
return this.name;
}
public long getTagBits() {
return this.tagBits;
}
/**
* This method is used to fully initialize the contents of the receiver. All methodinfos, fields infos
* will be therefore fully initialized and we can get rid of the bytes.
*/
protected void initialize() {
getModifiers();
getSelector();
getMethodDescriptor();
getExceptionTypeNames();
getGenericSignature();
getArgumentNames();
reset();
}
/**
* Answer true if the method is a class initializer, false otherwise.
* @return boolean
*/
public boolean isClinit() {
char[] selector = getSelector();
return selector[0] == '<' && selector.length == 8; // Can only match
}
/**
* Answer true if the method is a constructor, false otherwise.
* @return boolean
*/
public boolean isConstructor() {
char[] selector = getSelector();
return selector[0] == '<' && selector.length == 6; // Can only match
}
/**
* Return true if the field is a synthetic method, false otherwise.
* @return boolean
*/
public boolean isSynthetic() {
return (getModifiers() & ClassFileConstants.AccSynthetic) != 0;
}
private void readExceptionAttributes() {
int attributesCount = u2At(6);
int readOffset = 8;
for (int i = 0; i < attributesCount; i++) {
int utf8Offset = this.constantPoolOffsets[u2At(readOffset)] - this.structOffset;
char[] attributeName = utf8At(utf8Offset + 3, u2At(utf8Offset + 1));
if (CharOperation.equals(attributeName, AttributeNamesConstants.ExceptionsName)) {
// read the number of exception entries
int entriesNumber = u2At(readOffset + 6);
// place the readOffset at the beginning of the exceptions table
readOffset += 8;
if (entriesNumber == 0) {
this.exceptionNames = noException;
} else {
this.exceptionNames = new char[entriesNumber][];
for (int j = 0; j < entriesNumber; j++) {
utf8Offset =
this.constantPoolOffsets[u2At(
this.constantPoolOffsets[u2At(readOffset)] - this.structOffset + 1)]
- this.structOffset;
this.exceptionNames[j] = utf8At(utf8Offset + 3, u2At(utf8Offset + 1));
readOffset += 2;
}
}
} else {
readOffset += (6 + u4At(readOffset + 2));
}
}
if (this.exceptionNames == null) {
this.exceptionNames = noException;
}
}
private void readModifierRelatedAttributes() {
int attributesCount = u2At(6);
int readOffset = 8;
for (int i = 0; i < attributesCount; i++) {
int utf8Offset = this.constantPoolOffsets[u2At(readOffset)] - this.structOffset;
char[] attributeName = utf8At(utf8Offset + 3, u2At(utf8Offset + 1));
// test added for obfuscated .class file. See 79772
if (attributeName.length != 0) {
switch(attributeName[0]) {
case 'D' :
if (CharOperation.equals(attributeName, AttributeNamesConstants.DeprecatedName))
this.accessFlags |= ClassFileConstants.AccDeprecated;
break;
case 'S' :
if (CharOperation.equals(attributeName, AttributeNamesConstants.SyntheticName))
this.accessFlags |= ClassFileConstants.AccSynthetic;
break;
case 'A' :
if (CharOperation.equals(attributeName, AttributeNamesConstants.AnnotationDefaultName))
this.accessFlags |= ClassFileConstants.AccAnnotationDefault;
break;
case 'V' :
if (CharOperation.equals(attributeName, AttributeNamesConstants.VarargsName))
this.accessFlags |= ClassFileConstants.AccVarargs;
}
}
readOffset += (6 + u4At(readOffset + 2));
}
}
/**
* Answer the size of the receiver in bytes.
*
* @return int
*/
public int sizeInBytes() {
return this.attributeBytes;
}
public String toString() {
StringBuffer buffer = new StringBuffer();
toString(buffer);
return buffer.toString();
}
void toString(StringBuffer buffer) {
buffer.append(getClass().getName());
toStringContent(buffer);
}
protected void toStringContent(StringBuffer buffer) {
int modifiers = getModifiers();
char[] desc = getGenericSignature();
if (desc == null)
desc = getMethodDescriptor();
buffer
.append('{')
.append(
((modifiers & ClassFileConstants.AccDeprecated) != 0 ? "deprecated " : Util.EMPTY_STRING) //$NON-NLS-1$
+ ((modifiers & 0x0001) == 1 ? "public " : Util.EMPTY_STRING) //$NON-NLS-1$
+ ((modifiers & 0x0002) == 0x0002 ? "private " : Util.EMPTY_STRING) //$NON-NLS-1$
+ ((modifiers & 0x0004) == 0x0004 ? "protected " : Util.EMPTY_STRING) //$NON-NLS-1$
+ ((modifiers & 0x0008) == 0x000008 ? "static " : Util.EMPTY_STRING) //$NON-NLS-1$
+ ((modifiers & 0x0010) == 0x0010 ? "final " : Util.EMPTY_STRING) //$NON-NLS-1$
+ ((modifiers & 0x0040) == 0x0040 ? "bridge " : Util.EMPTY_STRING) //$NON-NLS-1$
+ ((modifiers & 0x0080) == 0x0080 ? "varargs " : Util.EMPTY_STRING)) //$NON-NLS-1$
.append(getSelector())
.append(desc)
.append('}');
}
private void readCodeAttribute() {
int attributesCount = u2At(6);
int readOffset = 8;
if (attributesCount != 0) {
for (int i = 0; i < attributesCount; i++) {
int utf8Offset = this.constantPoolOffsets[u2At(readOffset)] - this.structOffset;
char[] attributeName = utf8At(utf8Offset + 3, u2At(utf8Offset + 1));
if (CharOperation.equals(attributeName, AttributeNamesConstants.CodeName)) {
decodeCodeAttribute(readOffset);
if (this.argumentNames == null) {
this.argumentNames = noArgumentNames;
}
return;
} else {
readOffset += (6 + u4At(readOffset + 2));
}
}
}
this.argumentNames = noArgumentNames;
}
private void decodeCodeAttribute(int offset) {
int readOffset = offset + 10;
int codeLength = (int) u4At(readOffset);
readOffset += (4 + codeLength);
int exceptionTableLength = u2At(readOffset);
readOffset += 2;
if (exceptionTableLength != 0) {
for (int i = 0; i < exceptionTableLength; i++) {
readOffset += 8;
}
}
int attributesCount = u2At(readOffset);
readOffset += 2;
for (int i = 0; i < attributesCount; i++) {
int utf8Offset = this.constantPoolOffsets[u2At(readOffset)] - this.structOffset;
char[] attributeName = utf8At(utf8Offset + 3, u2At(utf8Offset + 1));
if (CharOperation.equals(attributeName, AttributeNamesConstants.LocalVariableTableName)) {
decodeLocalVariableAttribute(readOffset, codeLength);
}
readOffset += (6 + u4At(readOffset + 2));
}
}
private void decodeLocalVariableAttribute(int offset, int codeLength) {
int readOffset = offset + 6;
final int length = u2At(readOffset);
if (length != 0) {
readOffset += 2;
this.argumentNames = new char[length][];
int argumentNamesIndex = 0;
for (int i = 0; i < length; i++) {
int startPC = u2At(readOffset);
if (startPC == 0) {
int nameIndex = u2At(4 + readOffset);
int utf8Offset = this.constantPoolOffsets[nameIndex] - this.structOffset;
char[] localVariableName = utf8At(utf8Offset + 3, u2At(utf8Offset + 1));
if (!CharOperation.equals(localVariableName, ConstantPool.This)) {
this.argumentNames[argumentNamesIndex++] = localVariableName;
}
} else {
break;
}
readOffset += 10;
}
if (argumentNamesIndex != this.argumentNames.length) {
// resize
System.arraycopy(this.argumentNames, 0, (this.argumentNames = new char[argumentNamesIndex][]), 0, argumentNamesIndex);
}
}
}
private void decodeMethodParameters(int offset, MethodInfo methodInfo) {
int readOffset = offset + 6;
final int length = u1At(readOffset);
if (length != 0) {
readOffset += 1;
this.argumentNames = new char[length][];
for (int i = 0; i < length; i++) {
int nameIndex = u2At(readOffset);
if (nameIndex != 0) {
int utf8Offset = this.constantPoolOffsets[nameIndex] - this.structOffset;
char[] parameterName = utf8At(utf8Offset + 3, u2At(utf8Offset + 1));
this.argumentNames[i] = parameterName;
} else {
this.argumentNames[i] = CharOperation.concat(ARG, String.valueOf(i).toCharArray());
}
readOffset += 4;
}
}
}
}
