Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Copyright (c) 2000, 2008 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 /
 
 package org.eclipse.jdt.internal.compiler.classfmt;
 
 
 public class FieldInfo extends ClassFileStruct implements IBinaryFieldComparable {
 	protected int accessFlags;
 	protected int attributeBytes;
 	protected Constant constant;
 	protected char[] descriptor;
 	protected char[] name;
 	protected char[] signature;
 	protected int signatureUtf8Offset;
 	protected long tagBits;
 
 public static FieldInfo createField(byte classFileBytes[], int offsets[], int offset) {
 	FieldInfo fieldInfo = new FieldInfo(classFileBytesoffsetsoffset);
 	AnnotationInfo[] annotations = fieldInfo.readAttributes();
 	if (annotations == null)
 		return fieldInfo;
 	return new FieldInfoWithAnnotation(fieldInfoannotations);
 }

Parameters:
classFileBytes byte[]
offsets int[]
offset int
 
 protected FieldInfo (byte classFileBytes[], int offsets[], int offset) {
 	super(classFileBytesoffsetsoffset);
 	this. = -1;
 	this. = -1;
 }
 private AnnotationInfo[] decodeAnnotations(int offsetboolean runtimeVisible) {
 	int numberOfAnnotations = u2At(offset + 6);
 	if (numberOfAnnotations > 0) {
 		int readOffset = offset + 8;
 		AnnotationInfo[] newInfos = null;
 		int newInfoCount = 0;
 		for (int i = 0; i < numberOfAnnotationsi++) {
 			// With the last parameter being 'false', the data structure will not be flushed out
 				readOffset + this.runtimeVisiblefalse);
 			readOffset += newInfo.readOffset;
 			long standardTagBits = newInfo.standardAnnotationTagBits;
 			if (standardTagBits != 0) {
 				this. |= standardTagBits;
 			} else {
 				if (newInfos == null)
 					newInfos = new AnnotationInfo[numberOfAnnotations - i];
 				newInfos[newInfoCount++] = newInfo;
 			}
 		}
 		if (newInfos != null) {
 			if (newInfoCount != newInfos.length)
 				System.arraycopy(newInfos, 0, newInfos = new AnnotationInfo[newInfoCount], 0, newInfoCount);
 			return newInfos;
 		}
 	}
 	return null// nothing to record
 }
 public int compareTo(Object o) {
 	return new String(getName()).compareTo(new String(((FieldInfoo).getName()));
 }
 public boolean equals(Object o) {
 	if (!(o instanceof FieldInfo)) {
 		return false;
 	}
 	return CharOperation.equals(getName(), ((FieldInfoo).getName());
 }
 public int hashCode() {
 	return CharOperation.hashCode(getName());
 }
Return the constant of the field. Return org.eclipse.jdt.internal.compiler.impl.Constant.NotAConstant if there is none.

Returns:
org.eclipse.jdt.internal.compiler.impl.Constant
 
 public Constant getConstant() {
 	if (this. == null) {
 		// read constant
 	}
	return this.;
public char[] getGenericSignature() {
	if (this. != -1) {
		if (this. == null) {
			// decode the signature
			this. = utf8At(this. + 3, u2At(this. + 1));
		}
		return this.;
	}
	return null;
Answer an int whose bits are set according the access constants defined by the VM spec. Set the AccDeprecated and AccSynthetic bits if necessary

Returns:
int
public int getModifiers() {
	if (this. == -1) {
		// compute the accessflag. Don't forget the deprecated attribute
		this. = u2At(0);
	}
	return this.;
Answer the name of the field.

Returns:
char[]
public char[] getName() {
	if (this. == null) {
		// read the name
		int utf8Offset = this.[u2At(2)] - this.;
		this. = utf8At(utf8Offset + 3, u2At(utf8Offset + 1));
	}
	return this.;
public long getTagBits() {
	return this.;
Answer the resolved name of the receiver's type in the class file format as specified in section 4.3.2 of the Java 2 VM spec. For example: - java.lang.String is Ljava/lang/String; - an int is I - a 2 dimensional array of strings is [[Ljava/lang/String; - an array of floats is [F

Returns:
char[]
public char[] getTypeName() {
	if (this. == null) {
		// read the signature
		int utf8Offset = this.[u2At(4)] - this.;
		this. = utf8At(utf8Offset + 3, u2At(utf8Offset + 1));
	}
	return this.;

Returns:
the annotations or null if there is none.
	return null;
Return a wrapper that contains the constant of the field.

Returns:
java.lang.Object
	if (this. == null) {
		if (hasConstant()) {
			Constant fieldConstant = getConstant();
			switch (fieldConstant.typeID()) {
				case . :
					this. = new Integer(fieldConstant.intValue());
					break;
				case . :
					this. = new Byte(fieldConstant.byteValue());
					break;
					this. = new Short(fieldConstant.shortValue());
					break;
				case . :
					this. = new Character(fieldConstant.charValue());
					break;
					this. = new Float(fieldConstant.floatValue());
					break;
					this. = new Double(fieldConstant.doubleValue());
					break;
					this. = Util.toBoolean(fieldConstant.booleanValue());
					break;
				case . :
					this. = new Long(fieldConstant.longValue());
					break;
					this. = fieldConstant.stringValue();
			}
		}
	}
Return true if the field has a constant value attribute, false otherwise.

Returns:
boolean
public boolean hasConstant() {
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() {
Return true if the field is a synthetic field, false otherwise.

Returns:
boolean
public boolean isSynthetic() {
	int attributesCount = u2At(6);
	int readOffset = 8;
	AnnotationInfo[] annotations = null;
	for (int i = 0; i < attributesCounti++) {
		// check the name of each attribute
		int utf8Offset = this.[u2At(readOffset)] - this.;
		char[] attributeName = utf8At(utf8Offset + 3, u2At(utf8Offset + 1));
		if (attributeName.length > 0) {
			switch(attributeName[0]) {
				case 'S' :
					if (CharOperation.equals(.attributeName))
						this. = this.[u2At(readOffset + 6)] - this.;
					break;
				case 'R' :
					AnnotationInfo[] decodedAnnotations = null;
					if (CharOperation.equals(attributeName.)) {
						decodedAnnotations = decodeAnnotations(readOffsettrue);
else if (CharOperation.equals(attributeName.)) {
						decodedAnnotations = decodeAnnotations(readOffsetfalse);
					}
					if (decodedAnnotations != null) {
						if (annotations == null) {
							annotations = decodedAnnotations;
else {
							int length = annotations.length;
							AnnotationInfo[] combined = new AnnotationInfo[length + decodedAnnotations.length];
							System.arraycopy(annotations, 0, combined, 0, length);
							System.arraycopy(decodedAnnotations, 0, combinedlengthdecodedAnnotations.length);
							annotations = combined;
						}
					}
			}
		}
		readOffset += (6 + u4At(readOffset + 2));
	}
	this. = readOffset;
	return annotations;
private void readConstantAttribute() {
	int attributesCount = u2At(6);
	int readOffset = 8;
	boolean isConstant = false;
	for (int i = 0; i < attributesCounti++) {
		int utf8Offset = this.[u2At(readOffset)] - this.;
		char[] attributeName = utf8At(utf8Offset + 3, u2At(utf8Offset + 1));
		if (CharOperation
			isConstant = true;
			// read the right constant
			int relativeOffset = this.[u2At(readOffset + 6)] - this.;
			switch (u1At(relativeOffset)) {
					char[] sign = getTypeName();
					if (sign.length == 1) {
						switch (sign[0]) {
							case 'Z' : // boolean constant
								this. = BooleanConstant.fromValue(i4At(relativeOffset + 1) == 1);
								break;
							case 'I' : // integer constant
								this. = IntConstant.fromValue(i4At(relativeOffset + 1));
								break;
							case 'C' : // char constant
								this. = CharConstant.fromValue((chari4At(relativeOffset + 1));
								break;
							case 'B' : // byte constant
								this. = ByteConstant.fromValue((bytei4At(relativeOffset + 1));
								break;
							case 'S' : // short constant
								this. = ShortConstant.fromValue((shorti4At(relativeOffset + 1));
								break;
							default:
						}
else {
					}
					break;
					this. = FloatConstant.fromValue(floatAt(relativeOffset + 1));
					break;
					this. = DoubleConstant.fromValue(doubleAt(relativeOffset + 1));
					break;
					this. = LongConstant.fromValue(i8At(relativeOffset + 1));
					break;
					utf8Offset = this.[u2At(relativeOffset + 1)] - this.;
					this. =
						StringConstant.fromValue(
							String.valueOf(utf8At(utf8Offset + 3, u2At(utf8Offset + 1))));
					break;
			}
		}
		readOffset += (6 + u4At(readOffset + 2));
	}
	if (!isConstant) {
	}
	int attributesCount = u2At(6);
	int readOffset = 8;
	for (int i = 0; i < attributesCounti++) {
		int utf8Offset = this.[u2At(readOffset)] - this.;
		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.))
					break;
				case 'S' :
					if (CharOperation.equals(attributeName.))
					break;
			}
		}
		readOffset += (6 + u4At(readOffset + 2));
	}
Answer the size of the receiver in bytes.

Returns:
int
public int sizeInBytes() {
	return this.;
public void throwFormatException() throws ClassFormatException {
public String toString() {
	return buffer.toString();
protected void toStringContent(StringBuffer buffer) {
	int modifiers = getModifiers();
	buffer
		.append('{')
			((modifiers & .) != 0 ? "deprecated " : .//$NON-NLS-1$
				+ ((modifiers & 0x0001) == 1 ? "public " : .//$NON-NLS-1$
				+ ((modifiers & 0x0002) == 0x0002 ? "private " : .//$NON-NLS-1$
				+ ((modifiers & 0x0004) == 0x0004 ? "protected " : .//$NON-NLS-1$
				+ ((modifiers & 0x0008) == 0x000008 ? "static " : .//$NON-NLS-1$
				+ ((modifiers & 0x0010) == 0x0010 ? "final " : .//$NON-NLS-1$
				+ ((modifiers & 0x0040) == 0x0040 ? "volatile " : .//$NON-NLS-1$
				+ ((modifiers & 0x0080) == 0x0080 ? "transient " : .)) //$NON-NLS-1$
		.append(' ')
		.append(' ')
		.append('}')
New to GrepCode? Check out our FAQ X