/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.bcel.classfile;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.TreeSet;
import org.apache.bcel.Const;
import org.apache.bcel.generic.Type;
import org.apache.bcel.util.Args;
import org.apache.bcel.util.BCELComparator;
import org.apache.bcel.util.ClassQueue;
import org.apache.bcel.util.SyntheticRepository;
import org.apache.commons.lang3.ArrayUtils;
/**
* Represents a Java class, that is, the data structures, constant pool, fields, methods and commands contained in a Java
* .class file. See <a href="https://docs.oracle.com/javase/specs/">JVM specification</a> for details. The intent of
* this class is to represent a parsed or otherwise existing class file. Those interested in programmatically generating
* classes should see the <a href="../generic/ClassGen.html">ClassGen</a> class.
*
* @see org.apache.bcel.generic.ClassGen
*/
public class JavaClass extends AccessFlags implements Cloneable, Node, Comparable<JavaClass> {
private static final String CLASS_NAME_OBJECT = "java.lang.Object";
/**
* The standard class file extension.
*
* @since 6.7.0
*/
public static final String EXTENSION = ".class";
/**
* Empty array.
*
* @since 6.6.0
*/
public static final JavaClass[] EMPTY_ARRAY = {};
/** Source was read from heap. */
public static final byte HEAP = 1;
/** Source was read from file. */
public static final byte FILE = 2;
/** Source was read from ZIP. */
public static final byte ZIP = 3;
private static final boolean debug = Boolean.getBoolean("JavaClass.debug"); // Debugging on/off private static BCELComparator<JavaClass> bcelComparator = new BCELComparator<JavaClass>() {
@Override
public boolean equals(final JavaClass a, final JavaClass b) {
return a == b || a != null && b != null && Objects.equals(a.getClassName(), b.getClassName());
}
@Override
public int hashCode(final JavaClass o) {
return o != null ? Objects.hashCode(o.getClassName()) : 0;
}
};
/*
* Print debug information depending on 'JavaClass.debug'
*/
static void Debug(final String str) {
if (debug) { System.out.println(str);
}
}
/**
* Gets the comparison strategy object.
*
* @return Comparison strategy object.
*/
public static BCELComparator<JavaClass> getComparator() {
return bcelComparator;
}
private static String indent(final Object obj) {
final StringTokenizer tokenizer = new StringTokenizer(obj.toString(), "\n"); final StringBuilder buf = new StringBuilder(); while (tokenizer.hasMoreTokens()) { buf.append("\t").append(tokenizer.nextToken()).append("\n");
}
return buf.toString();
}
/**
* Sets the comparison strategy object.
*
* @param comparator Comparison strategy object.
*/
public static void setComparator(final BCELComparator<JavaClass> comparator) {
bcelComparator = comparator; }
private String fileName;
private final String packageName;
private String sourceFileName = "<Unknown>";
private int classNameIndex;
private int superclassNameIndex;
private String className;
private String superclassName;
private int major;
private int minor; // Compiler version
private ConstantPool constantPool; // Constant pool
private int[] interfaces; // implemented interfaces
private String[] interfaceNames;
private Field[] fields; // Fields, that is, variables of class
private Method[] methods; // methods defined in the class
private Attribute[] attributes; // attributes defined in the class
private AnnotationEntry[] annotations; // annotations defined on the class
private byte source = HEAP; // Generated in memory
private boolean isAnonymous;
private boolean isNested;
private boolean isRecord;
private boolean computedNestedTypeStatus;
private boolean computedRecord;
/**
* In cases where we go ahead and create something, use the default SyntheticRepository, because we don't know any
* better.
*/
private transient org.apache.bcel.util.Repository repository = SyntheticRepository.getInstance();
/**
* Constructor gets all contents as arguments.
*
* @param classNameIndex Class name.
* @param superclassNameIndex Superclass name.
* @param fileName File name.
* @param major Major compiler version.
* @param minor Minor compiler version.
* @param accessFlags Access rights defined by bit flags.
* @param constantPool Array of constants.
* @param interfaces Implemented interfaces.
* @param fields Class fields.
* @param methods Class methods.
* @param attributes Class attributes.
*/
public JavaClass(final int classNameIndex, final int superclassNameIndex, final String fileName, final int major, final int minor, final int accessFlags,
final ConstantPool constantPool, final int[] interfaces, final Field[] fields, final Method[] methods, final Attribute[] attributes) {
this(classNameIndex, superclassNameIndex, fileName, major, minor, accessFlags, constantPool, interfaces, fields, methods, attributes, HEAP); }
/**
* Constructor gets all contents as arguments.
*
* @param classNameIndex Index into constant pool referencing a ConstantClass that represents this class.
* @param superclassNameIndex Index into constant pool referencing a ConstantClass that represents this class's superclass.
* @param fileName File name.
* @param major Major compiler version.
* @param minor Minor compiler version.
* @param accessFlags Access rights defined by bit flags.
* @param constantPool Array of constants.
* @param interfaces Implemented interfaces.
* @param fields Class fields.
* @param methods Class methods.
* @param attributes Class attributes.
* @param source Read from file or generated in memory.
*/
public JavaClass(final int classNameIndex, final int superclassNameIndex, final String fileName, final int major, final int minor, final int accessFlags,
final ConstantPool constantPool, int[] interfaces, Field[] fields, Method[] methods, Attribute[] attributes, final byte source) {
super(accessFlags); interfaces = ArrayUtils.nullToEmpty(interfaces); if (attributes == null) { attributes = Attribute.EMPTY_ARRAY;
}
if (fields == null) { fields = Field.EMPTY_ARRAY;
}
if (methods == null) { methods = Method.EMPTY_ARRAY;
}
this.classNameIndex = classNameIndex; this.superclassNameIndex = superclassNameIndex; this.fileName = fileName; this.major = major; this.minor = minor; this.constantPool = constantPool; this.interfaces = interfaces; this.fields = fields; this.methods = methods; this.attributes = attributes; this.source = source;
// Get source file name if available
for (final Attribute attribute : attributes) { if (attribute instanceof SourceFile) { sourceFileName = ((SourceFile) attribute).getSourceFileName(); break;
}
}
/*
* According to the specification the following entries must be of type 'ConstantClass' but we check that anyway via the
* 'ConstPool.getConstant' method.
*/
className = constantPool.getConstantString(classNameIndex, Const.CONSTANT_Class); className = Utility.compactClassName(className, false); final int index = className.lastIndexOf('.'); if (index < 0) { packageName = "";
} else {
packageName = className.substring(0, index);
}
if (superclassNameIndex > 0) {
// May be zero -> class is java.lang.Object
superclassName = constantPool.getConstantString(superclassNameIndex, Const.CONSTANT_Class); superclassName = Utility.compactClassName(superclassName, false);
} else {
superclassName = CLASS_NAME_OBJECT;
}
interfaceNames = new String[interfaces.length]; for (int i = 0; i < interfaces.length; i++) { final String str = constantPool.getConstantString(interfaces[i], Const.CONSTANT_Class); interfaceNames[i] = Utility.compactClassName(str, false);
}
}
/**
* Called by objects that are traversing the nodes of the tree implicitly defined by the contents of a Java class.
* That is, the hierarchy of methods, fields, attributes, and other elements forms a tree of objects.
*
* @param v Visitor object.
*/
@Override
public void accept(final Visitor v) {
v.visitJavaClass(this); }
/**
* Return the natural ordering of two JavaClasses. This ordering is based on the class name
*
* @since 6.0
*/
@Override
public int compareTo(final JavaClass obj) {
return getClassName().compareTo(obj.getClassName());
}
private void computeIsRecord() {
if (computedRecord) { return;
}
for (final Attribute attribute : this.attributes) { if (attribute instanceof Record) { isRecord = true; break;
}
}
this.computedRecord = true; }
private void computeNestedTypeStatus() {
if (computedNestedTypeStatus) { return;
}
for (final Attribute attribute : this.attributes) { if (attribute instanceof InnerClasses) { ((InnerClasses) attribute).forEach(innerClass -> { boolean innerClassAttributeRefersToMe = false; String innerClassName = constantPool.getConstantString(innerClass.getInnerClassIndex(), Const.CONSTANT_Class); innerClassName = Utility.compactClassName(innerClassName, false); if (innerClassName.equals(getClassName())) { innerClassAttributeRefersToMe = true;
}
if (innerClassAttributeRefersToMe) { this.isNested = true; if (innerClass.getInnerNameIndex() == 0) { this.isAnonymous = true;
}
}
});
}
}
this.computedNestedTypeStatus = true; }
/**
* Creates a deep copy of this class.
*
* @return deep copy of this class.
*/
public JavaClass copy() {
try {
final JavaClass c = (JavaClass) clone(); c.constantPool = constantPool.copy(); c.interfaces = interfaces.clone(); c.interfaceNames = interfaceNames.clone(); c.fields = new Field[fields.length]; Arrays.setAll(c.fields, i -> fields[i].copy(c.constantPool)); c.methods = new Method[methods.length]; Arrays.setAll(c.methods, i -> methods[i].copy(c.constantPool)); c.attributes = new Attribute[attributes.length]; Arrays.setAll(c.attributes, i -> attributes[i].copy(c.constantPool)); return c; } catch (final CloneNotSupportedException e) { return null;
}
}
/**
* Dumps Java class to output stream in binary format.
*
* <p>
* For versions 45.0 through 45.2, all method Code attributes use compact four-byte headers if any method's Code attribute returns {@code true} from
* {@link Code#isCompactCodeHeader()}. Otherwise, all method Code attributes use standard eight-byte headers. Versions 45.3 and later always use standard
* headers, including after a version change. The header size refers only to {@code max_stack}, {@code max_locals}, and {@code code_length}.
* These encoding adjustments do not modify the methods or their attributes.
* </p>
*
* @param file Output stream.
* @throws IOException Thrown if an I/O error occurs.
* @throws ClassFormatException Thrown if a method's values do not fit the selected Code header layout.
*/
public void dump(final DataOutputStream file) throws IOException {
// Use one layout for all method Code headers. A version change can require widening headers without modifying shared attributes.
final boolean compactCodeHeader = major == Const.MAJOR_1_1 && minor < Const.MINOR_1_1 && Arrays.stream(methods) .map(Method::getCode).filter(Objects::nonNull).anyMatch(Code::isCompactCodeHeader); file.writeInt(Const.JVM_CLASSFILE_MAGIC); file.writeShort(minor); file.writeShort(major); constantPool.dump(file); file.writeShort(super.getAccessFlags()); file.writeShort(classNameIndex); file.writeShort(superclassNameIndex); file.writeShort(Args.requireU2(interfaces.length, "interfaces.length")); for (final int interface1 : interfaces) { file.writeShort(interface1);
}
file.writeShort(Args.requireU2(fields.length, "fields.length")); for (final Field field : fields) { field.dump(file);
}
file.writeShort(Args.requireU2(methods.length, "methods.length")); for (final Method method : methods) { method.dump(file, compactCodeHeader);
}
if (attributes != null) { file.writeShort(Args.requireU2(attributes.length, "attributes.length")); for (final Attribute attribute : attributes) { attribute.dump(file);
}
} else {
file.writeShort(0);
}
file.flush(); }
/**
* Dumps class to a file.
*
* @param file Output file.
* @throws IOException Thrown if an I/O error occurs.
*/
public void dump(final File file) throws IOException {
final String parent = file.getParent(); if (parent != null) { final File dir = new File(parent); if (!dir.mkdirs() && !dir.isDirectory()) { throw new IOException("Could not create the directory " + dir);
}
}
try (DataOutputStream dos = new DataOutputStream(new FileOutputStream(file))) { dump(dos);
}
}
/**
* Dumps Java class to output stream in binary format.
*
* @param file Output stream.
* @throws IOException Thrown if an I/O error occurs.
*/
public void dump(final OutputStream file) throws IOException {
dump(new DataOutputStream(file)); }
/**
* Dumps class to a file named fileName.
*
* @param fileName Output file name.
* @throws IOException Thrown if an I/O error occurs.
*/
public void dump(final String fileName) throws IOException {
dump(new File(fileName)); }
/**
* Return value as defined by given BCELComparator strategy. By default two JavaClass objects are said to be equal when
* their class names are equal.
*
* @see Object#equals(Object)
*/
@Override
public boolean equals(final Object obj) {
return obj instanceof JavaClass && bcelComparator.equals(this, (JavaClass) obj);
}
/**
* Finds a visible field by name and type in this class and its superclasses.
*
* @param fieldName The field name to find.
* @param fieldType The field type to find.
* @return field matching given name and type, null if field is not found or not accessible from this class.
* @throws ClassNotFoundException Thrown if the class cannot be found.
* @since 6.8.0
*/
public Field findField(final String fieldName, final Type fieldType) throws ClassNotFoundException {
return findFieldVisit(fieldName, fieldType, new HashSet<>());
}
private Field findFieldVisit(final String fieldName, final Type fieldType, final Set<JavaClass> visiting) throws ClassNotFoundException {
if (!visiting.add(this)) { throw new ClassFormatException(getClassName());
}
try {
for (final Field field : fields) { if (field.getName().equals(fieldName)) { final Type fType = Type.getType(field.getSignature());
// TODO: Check if assignment compatibility is sufficient. What does Sun do?
if (fType.equals(fieldType)) { return field;
}
}
}
final JavaClass superclass = getSuperClass(); if (superclass != null && !CLASS_NAME_OBJECT.equals(superclass.getClassName())) { final Field f = superclass.findFieldVisit(fieldName, fieldType, visiting); if (f != null && (f.isPublic() || f.isProtected() || !f.isPrivate() && packageName.equals(superclass.getPackageName()))) { return f;
}
}
final JavaClass[] implementedInterfaces = getInterfaces(); if (implementedInterfaces != null) { for (final JavaClass implementedInterface : implementedInterfaces) { final Field f = implementedInterface.findFieldVisit(fieldName, fieldType, visiting); if (f != null) { return f;
}
}
}
return null;
} finally {
visiting.remove(this);
}
}
/**
* Gets all interfaces implemented by this JavaClass (transitively).
*
* @return all interfaces.
* @throws ClassNotFoundException Thrown if any of the class's superclasses or interfaces can't be found.
*/
public JavaClass[] getAllInterfaces() throws ClassNotFoundException {
final ClassQueue queue = new ClassQueue(); final Set<JavaClass> allInterfaces = new TreeSet<>(); final Set<JavaClass> visited = new HashSet<>(); queue.enqueue(this); while (!queue.empty()) { final JavaClass clazz = queue.dequeue(); if (!visited.add(clazz)) { continue;
}
final JavaClass souper = clazz.getSuperClass(); final JavaClass[] interfaces = clazz.getInterfaces(); if (clazz.isInterface()) { allInterfaces.add(clazz); } else if (souper != null) { queue.enqueue(souper);
}
for (final JavaClass iface : interfaces) { queue.enqueue(iface);
}
} return allInterfaces.toArray(EMPTY_ARRAY);
}
/**
* Gets annotations on the class.
*
* @return Annotations on the class.
* @since 6.0
*/
public AnnotationEntry[] getAnnotationEntries() {
if (annotations == null) { annotations = AnnotationEntry.createAnnotationEntries(getAttributes());
}
return annotations;
}
/**
* Gets attribute for given tag.
*
* @param <T> The attribute type.
* @param tag The attribute tag.
* @return Attribute for given tag, null if not found.
* Refer to {@link org.apache.bcel.Const#ATTR_UNKNOWN} constants named ATTR_* for possible values.
* @since 6.10.0
*/
@SuppressWarnings("unchecked")
public final <T extends Attribute> T getAttribute(final byte tag) {
for (final Attribute attribute : getAttributes()) { if (attribute.getTag() == tag) { return (T) attribute;
}
}
return null;
}
/**
* Gets attributes of the class.
*
* @return Attributes of the class.
*/
public Attribute[] getAttributes() {
return attributes;
}
/**
* Gets class in binary format.
*
* @return class in binary format.
*/
public byte[] getBytes() {
final ByteArrayOutputStream baos = new ByteArrayOutputStream(); try (DataOutputStream dos = new DataOutputStream(baos)) { dump(dos); } catch (final IOException e) { e.printStackTrace(); } return baos.toByteArray();
}
/**
* Gets the class name.
*
* @return Class name.
*/
public String getClassName() {
return className;
}
/**
* Gets the class name index.
*
* @return Class name index.
*/
public int getClassNameIndex() {
return classNameIndex;
}
/**
* Gets the constant pool.
*
* @return Constant pool.
*/
public ConstantPool getConstantPool() {
return constantPool;
}
/**
* Gets the fields.
*
* @return Fields, that is, variables of the class. Like the JVM spec mandates for the classfile format, these fields are
* those specific to this class, and not those of the superclass or superinterfaces.
*/
public Field[] getFields() {
return fields;
}
/**
* Gets the file name of class.
*
* @return File name of class, aka SourceFile attribute value.
*/
public String getFileName() {
return fileName;
}
/**
* Gets indices in constant pool of implemented interfaces.
*
* @return Indices in constant pool of implemented interfaces.
*/
public int[] getInterfaceIndices() {
return interfaces;
}
/**
* Gets names of implemented interfaces.
*
* @return Names of implemented interfaces.
*/
public String[] getInterfaceNames() {
return interfaceNames;
}
/**
* Gets interfaces directly implemented by this JavaClass.
*
* @return The interfaces.
* @throws ClassNotFoundException Thrown if any of the class's interfaces can't be found.
*/
public JavaClass[] getInterfaces() throws ClassNotFoundException {
final String[] interfaces = getInterfaceNames(); final JavaClass[] classes = new JavaClass[interfaces.length]; for (int i = 0; i < interfaces.length; i++) { classes[i] = repository.loadClass(interfaces[i]);
}
return classes;
}
/**
* Gets the major number of class file version.
*
* @return Major number of class file version.
*/
public int getMajor() {
return major;
}
/**
* Gets a Method corresponding to java.lang.reflect.Method if any.
*
* @param m The method to find.
* @return A {@link Method} corresponding to java.lang.reflect.Method if any.
*/
public Method getMethod(final java.lang.reflect.Method m) {
for (final Method method : methods) { if (m.getName().equals(method.getName()) && m.getModifiers() == method.getModifiers() && Type.getSignature(m).equals(method.getSignature())) { return method;
}
}
return null;
}
/**
* Gets the methods of the class.
*
* @return Methods of the class.
*/
public Method[] getMethods() {
return methods;
}
/**
* Gets the minor number of class file version.
*
* @return Minor number of class file version.
*/
public int getMinor() {
return minor;
}
/**
* Gets the package name.
*
* @return Package name.
*/
public String getPackageName() {
return packageName;
}
/**
* Gets the ClassRepository which holds its definition. By default this is the same as
* SyntheticRepository.getInstance().
*
* @return The repository.
*/
public org.apache.bcel.util.Repository getRepository() {
return repository;
}
/**
* Gets the source.
*
* @return either HEAP (generated), FILE, or ZIP.
*/
public final byte getSource() {
return source;
}
/**
* Gets the file name where this class was read from.
*
* @return file name where this class was read from.
*/
public String getSourceFileName() {
return sourceFileName;
}
/**
* Gets the source file path including the package path.
*
* @return path to original source file of parsed class, relative to original source directory.
* @since 6.7.0
*/
public String getSourceFilePath() {
final StringBuilder outFileName = new StringBuilder(); if (!packageName.isEmpty()) { outFileName.append(Utility.packageToPath(packageName)); outFileName.append('/');
}
outFileName.append(sourceFileName); return outFileName.toString();
}
/**
* Gets the superclass for this JavaClass object, or null if this is {@link Object}.
*
* @return The superclass for this JavaClass object, or null if this is {@link Object}.
* @throws ClassNotFoundException Thrown if the superclass can't be found.
*/
public JavaClass getSuperClass() throws ClassNotFoundException {
if (CLASS_NAME_OBJECT.equals(getClassName())) { return null;
}
return repository.loadClass(getSuperclassName());
}
/**
* Gets the list of superclasses of this class in ascending order.
*
* @return list of superclasses of this class in ascending order, that is, {@link Object} is always the last element.
* @throws ClassNotFoundException Thrown if any of the superclasses can't be found.
*/
public JavaClass[] getSuperClasses() throws ClassNotFoundException {
JavaClass clazz = this; final List<JavaClass> allSuperClasses = new ArrayList<>(); final Set<JavaClass> visited = new HashSet<>(); visited.add(this); for (clazz = clazz.getSuperClass(); clazz != null; clazz = clazz.getSuperClass()) { if (!visited.add(clazz)) { throw new ClassFormatException(clazz.getClassName());
}
allSuperClasses.add(clazz);
}
return allSuperClasses.toArray(EMPTY_ARRAY);
}
/**
* Gets the superclass name of this class. In the case that this class is {@link Object}, it will return itself
* ({@link Object}). This is probably incorrect but isn't fixed at this time to not break existing clients.
*
* @return Superclass name.
*/
public String getSuperclassName() {
return superclassName;
}
/**
* Gets the class name index.
*
* @return Class name index.
*/
public int getSuperclassNameIndex() {
return superclassNameIndex;
}
/**
* Return value as defined by given BCELComparator strategy. By default return the hash code of the class name.
*
* @see Object#hashCode()
*/
@Override
public int hashCode() {
return bcelComparator.hashCode(this);
}
/**
* Checks if this class is an implementation of interface inter.
*
* @param inter The interface to check.
* @return true, if this class is an implementation of interface inter.
* @throws ClassNotFoundException Thrown if superclasses or superinterfaces of this class can't be found.
*/
public boolean implementationOf(final JavaClass inter) throws ClassNotFoundException {
if (!inter.isInterface()) { throw new IllegalArgumentException(inter.getClassName() + " is not an interface");
}
if (equals(inter)) { return true;
}
final JavaClass[] superInterfaces = getAllInterfaces(); for (final JavaClass superInterface : superInterfaces) { if (superInterface.equals(inter)) { return true;
}
}
return false;
}
/**
* Equivalent to runtime "instanceof" operator.
*
* @param superclass The superclass to check.
* @return true if this JavaClass is derived from the superclass.
* @throws ClassNotFoundException Thrown if superclasses or superinterfaces of this object can't be found.
*/
public final boolean instanceOf(final JavaClass superclass) throws ClassNotFoundException {
if (equals(superclass)) { return true;
}
for (final JavaClass clazz : getSuperClasses()) { if (clazz.equals(superclass)) { return true;
}
}
if (superclass.isInterface()) { return implementationOf(superclass);
}
return false;
}
/**
* Tests whether this class is anonymous.
*
* @return true if anonymous.
* @since 6.0
*/
public final boolean isAnonymous() {
computeNestedTypeStatus(); return this.isAnonymous;
}
/**
* Tests whether this is a class.
*
* @return true if this is a class.
*/
public final boolean isClass() {
return (super.getAccessFlags() & Const.ACC_INTERFACE) == 0;
}
/**
* Tests whether this class is nested.
*
* @return true if nested.
* @since 6.0
*/
public final boolean isNested() {
computeNestedTypeStatus(); return this.isNested;
}
/**
* Tests whether this class was declared as a record
*
* @return true if a record attribute is present, false otherwise.
* @since 6.9.0
*/
public boolean isRecord() {
computeIsRecord(); return this.isRecord;
}
/**
* Tests whether the ACC_SUPER flag is set.
*
* @return true if the ACC_SUPER flag is set.
*/
public final boolean isSuper() {
return (super.getAccessFlags() & Const.ACC_SUPER) != 0;
}
/**
* Sets the attributes.
*
* @param attributes The attributes.
*/
public void setAttributes(final Attribute[] attributes) {
this.attributes = attributes != null ? attributes : Attribute.EMPTY_ARRAY; }
/**
* Sets the class name.
*
* @param className The class name.
*/
public void setClassName(final String className) {
this.className = className; }
/**
* Sets the class name index.
*
* @param classNameIndex The class name index.
*/
public void setClassNameIndex(final int classNameIndex) {
this.classNameIndex = classNameIndex; }
/**
* Sets the constant pool.
*
* @param constantPool The constant pool.
*/
public void setConstantPool(final ConstantPool constantPool) {
this.constantPool = constantPool; }
/**
* Sets the fields.
*
* @param fields The fields.
*/
public void setFields(final Field[] fields) {
this.fields = fields != null ? fields : Field.EMPTY_ARRAY; }
/**
* Sets the source file name of the class, that is, the SourceFile attribute value.
*
* @param fileName The file name.
*/
public void setFileName(final String fileName) {
this.fileName = fileName; }
/**
* Sets the interface names.
*
* @param interfaceNames The interface names.
*/
public void setInterfaceNames(final String[] interfaceNames) {
this.interfaceNames = ArrayUtils.nullToEmpty(interfaceNames); }
/**
* Sets the interfaces.
*
* @param interfaces The interfaces.
*/
public void setInterfaces(final int[] interfaces) {
this.interfaces = ArrayUtils.nullToEmpty(interfaces); }
/**
* Sets the major version.
*
* @param major The major version.
*/
public void setMajor(final int major) {
this.major = major; }
/**
* Sets the methods.
*
* @param methods The methods.
*/
public void setMethods(final Method[] methods) {
this.methods = methods != null ? methods : Method.EMPTY_ARRAY; }
/**
* Sets the minor version.
*
* @param minor The minor version.
*/
public void setMinor(final int minor) {
this.minor = minor; }
/**
* Sets the ClassRepository which loaded the JavaClass. Should be called immediately after parsing is done.
*
* @param repository The repository.
*/
public void setRepository(final org.apache.bcel.util.Repository repository) { // TODO make protected?
this.repository = repository; }
/**
* Sets absolute path to file this class was read from.
*
* @param sourceFileName The source file name.
*/
public void setSourceFileName(final String sourceFileName) {
this.sourceFileName = sourceFileName; }
/**
* Sets the superclass name.
*
* @param superclassName The superclass name.
*/
public void setSuperclassName(final String superclassName) {
this.superclassName = superclassName; }
/**
* Sets the superclass name index.
*
* @param superclassNameIndex The superclass name index.
*/
public void setSuperclassNameIndex(final int superclassNameIndex) {
this.superclassNameIndex = superclassNameIndex; }
/**
* @return String representing class contents.
*/
@Override
public String toString() {
String access = Utility.accessToString(super.getAccessFlags(), true); access = access.isEmpty() ? "" : access + " "; final StringBuilder buf = new StringBuilder(128); buf.append(access).append(Utility.classOrInterface(super.getAccessFlags())).append(" ").append(className).append(" extends ") .append(Utility.compactClassName(superclassName, false)).append('\n'); final int size = interfaces.length; if (size > 0) { buf.append("implements\t\t"); for (int i = 0; i < size; i++) { buf.append(interfaceNames[i]); if (i < size - 1) { buf.append(", ");
}
}
buf.append('\n');
}
buf.append("file name\t\t").append(fileName).append('\n'); buf.append("compiled from\t\t").append(sourceFileName).append('\n'); buf.append("compiler version\t").append(major).append(".").append(minor).append('\n'); buf.append("access flags\t\t").append(super.getAccessFlags()).append('\n'); buf.append("constant pool\t\t").append(constantPool.getLength()).append(" entries\n"); buf.append("ACC_SUPER flag\t\t").append(isSuper()).append("\n"); if (attributes.length > 0) { buf.append("\nAttribute(s):\n"); for (final Attribute attribute : attributes) { buf.append(indent(attribute));
}
}
final AnnotationEntry[] annotations = getAnnotationEntries(); if (annotations != null && annotations.length > 0) { buf.append("\nAnnotation(s):\n"); for (final AnnotationEntry annotation : annotations) { buf.append(indent(annotation));
}
}
if (fields.length > 0) { buf.append("\n").append(fields.length).append(" fields:\n"); for (final Field field : fields) { buf.append("\t").append(field).append('\n');
}
}
if (methods.length > 0) { buf.append("\n").append(methods.length).append(" methods:\n"); for (final Method method : methods) { buf.append("\t").append(method).append('\n');
}
}
return buf.toString();
}
}