package com.sun.org.apache.bcel.internal.classfile;
/* ====================================================================
* The Apache Software License, Version 1.1
*
* Copyright (c) 2001 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. The end-user documentation included with the redistribution,
* if any, must include the following acknowledgment:
* "This product includes software developed by the
* Apache Software Foundation (http://www.apache.org/)."
* Alternately, this acknowledgment may appear in the software itself,
* if and wherever such third-party acknowledgments normally appear.
*
* 4. The names "Apache" and "Apache Software Foundation" and
* "Apache BCEL" must not be used to endorse or promote products
* derived from this software without prior written permission. For
* written permission, please contact apache@apache.org.
*
* 5. Products derived from this software may not be called "Apache",
* "Apache BCEL", nor may "Apache" appear in their name, without
* prior written permission of the Apache Software Foundation.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation. For more
* information on the Apache Software Foundation, please see
* .
*/
import com.sun.org.apache.bcel.internal.Constants;
import com.sun.org.apache.bcel.internal.Repository;
import java.io.*;
import java.util.StringTokenizer;
/**
* Represents a Java class, i.e., the data structures, constant pool,
* fields, methods and commands contained in a Java .class file.
* See JVM
* specification for details.
*
* @version $Id: JavaClass.java,v 1.1 2003/12/12 08:57:41 rameshm Exp $
* @author M. Dahm
*/
public class JavaClass extends AccessFlags implements Cloneable, Node {
private String file_name;
private String package_name;
private String source_file_name = "";
private int class_name_index;
private int superclass_name_index;
private String class_name;
private String superclass_name;
private int major, minor; // Compiler version
private ConstantPool constant_pool; // Constant pool
private int[] interfaces; // implemented interfaces
private String[] interface_names;
private Field[] fields; // Fields, i.e., variables of class
private Method[] methods; // methods defined in the class
private Attribute[] attributes; // attributes defined in the class
private byte source = HEAP; // Generated in memory
public static final byte HEAP = 1;
public static final byte FILE = 2;
public static final byte ZIP = 3;
static boolean debug = false; // Debugging on/off
static char sep = '/'; // directory separator
/**
* Constructor gets all contents as arguments.
*
* @param class_name Class name
* @param superclass_name Superclass name
* @param file_name File name
* @param major Major compiler version
* @param minor Minor compiler version
* @param access_flags Access rights defined by bit flags
* @param constant_pool 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(int class_name_index,
int superclass_name_index,
String file_name,
int major,
int minor,
int access_flags,
ConstantPool constant_pool,
int[] interfaces,
Field[] fields,
Method[] methods,
Attribute[] attributes,
byte source)
{
if(interfaces == null) // Allowed for backward compatibility
interfaces = new int[0];
if(attributes == null)
this.attributes = new Attribute[0];
if(fields == null)
fields = new Field[0];
if(methods == null)
methods = new Method[0];
this.class_name_index = class_name_index;
this.superclass_name_index = superclass_name_index;
this.file_name = file_name;
this.major = major;
this.minor = minor;
this.access_flags = access_flags;
this.constant_pool = constant_pool;
this.interfaces = interfaces;
this.fields = fields;
this.methods = methods;
this.attributes = attributes;
this.source = source;
// Get source file name if available
for(int i=0; i < attributes.length; i++) {
if(attributes[i] instanceof SourceFile) {
source_file_name = ((SourceFile)attributes[i]).getSourceFileName();
break;
}
}
// Get class name and superclass name
ConstantUtf8 name;
/* According to the specification the following entries must be of type
* `ConstantClass' but we check that anyway via the
* `ConstPool.getConstant' method.
*/
class_name = constant_pool.getConstantString(class_name_index,
Constants.CONSTANT_Class);
class_name = Utility.compactClassName(class_name, false);
int index = class_name.lastIndexOf('.');
if(index < 0)
package_name = "";
else
package_name = class_name.substring(0, index);
if(superclass_name_index > 0) { // May be zero -> class is java.lang.Object
superclass_name = constant_pool.getConstantString(superclass_name_index,
Constants.CONSTANT_Class);
superclass_name = Utility.compactClassName(superclass_name, false);
}
else
superclass_name = "java.lang.Object";
interface_names = new String[interfaces.length];
for(int i=0; i < interfaces.length; i++) {
String str = constant_pool.getConstantString(interfaces[i], Constants.CONSTANT_Class);
interface_names[i] = Utility.compactClassName(str, false);
}
}
/**
* Constructor gets all contents as arguments.
*
* @param class_name Class name
* @param superclass_name Superclass name
* @param file_name File name
* @param major Major compiler version
* @param minor Minor compiler version
* @param access_flags Access rights defined by bit flags
* @param constant_pool Array of constants
* @param interfaces Implemented interfaces
* @param fields Class fields
* @param methods Class methods
* @param attributes Class attributes
*/
public JavaClass(int class_name_index,
int superclass_name_index,
String file_name,
int major,
int minor,
int access_flags,
ConstantPool constant_pool,
int[] interfaces,
Field[] fields,
Method[] methods,
Attribute[] attributes) {
this(class_name_index, superclass_name_index, file_name, major, minor, access_flags,
constant_pool, interfaces, fields, methods, attributes, HEAP);
}
/**
* Called by objects that are traversing the nodes of the tree implicitely
* defined by the contents of a Java class. I.e., the hierarchy of methods,
* fields, attributes, etc. spawns a tree of objects.
*
* @param v Visitor object
*/
public void accept(Visitor v) {
v.visitJavaClass(this);
}
/* Print debug information depending on `JavaClass.debug'
*/
static final void Debug(String str) {
if(debug)
System.out.println(str);
}
/**
* Dump class to a file.
*
* @param file Output file
* @throw IOException
*/
public void dump(File file) throws IOException
{
String parent = file.getParent();
if(parent != null) {
File dir = new File(parent);
if(dir != null)
dir.mkdirs();
}
dump(new DataOutputStream(new FileOutputStream(file)));
}
/**
* Dump class to a file named file_name.
*
* @param file_name Output file name
* @exception IOException
*/
public void dump(String file_name) throws IOException
{
dump(new File(file_name));
}
/**
* @return class in binary format
*/
public byte[] getBytes() {
ByteArrayOutputStream s = new ByteArrayOutputStream();
DataOutputStream ds = new DataOutputStream(s);
try {
dump(ds);
ds.close();
} catch(IOException e) { e.printStackTrace(); }
return s.toByteArray();
}
/**
* Dump Java class to output stream in binary format.
*
* @param file Output stream
* @exception IOException
*/
public void dump(OutputStream file) throws IOException {
dump(new DataOutputStream(file));
}
/**
* Dump Java class to output stream in binary format.
*
* @param file Output stream
* @exception IOException
*/
public void dump(DataOutputStream file) throws IOException
{
file.writeInt(0xcafebabe);
file.writeShort(minor);
file.writeShort(major);
constant_pool.dump(file);
file.writeShort(access_flags);
file.writeShort(class_name_index);
file.writeShort(superclass_name_index);
file.writeShort(interfaces.length);
for(int i=0; i < interfaces.length; i++)
file.writeShort(interfaces[i]);
file.writeShort(fields.length);
for(int i=0; i < fields.length; i++)
fields[i].dump(file);
file.writeShort(methods.length);
for(int i=0; i < methods.length; i++)
methods[i].dump(file);
if(attributes != null) {
file.writeShort(attributes.length);
for(int i=0; i < attributes.length; i++)
attributes[i].dump(file);
}
else
file.writeShort(0);
file.close();
}
/**
* @return Attributes of the class.
*/
public Attribute[] getAttributes() { return attributes; }
/**
* @return Class name.
*/
public String getClassName() { return class_name; }
/**
* @return Package name.
*/
public String getPackageName() { return package_name; }
/**
* @return Class name index.
*/
public int getClassNameIndex() { return class_name_index; }
/**
* @return Constant pool.
*/
public ConstantPool getConstantPool() { return constant_pool; }
/**
* @return Fields, i.e., variables of the class.
*/
public Field[] getFields() { return fields; }
/**
* @return File name of class, aka SourceFile attribute value
*/
public String getFileName() { return file_name; }
/**
* @return Names of implemented interfaces.
*/
public String[] getInterfaceNames() { return interface_names; }
/**
* @return Implemented interfaces.
*/
public int[] getInterfaces() { return interfaces; }
/**
* @return Major number of compiler version.
*/
public int getMajor() { return major; }
/**
* @return Methods of the class.
*/
public Method[] getMethods() { return methods; }
/**
* @return Minor number of compiler version.
*/
public int getMinor() { return minor; }
/**
* @return sbsolute path to file where this class was read from
*/
public String getSourceFileName() { return source_file_name; }
/**
* @return Superclass name.
*/
public String getSuperclassName() { return superclass_name; }
/**
* @return Class name index.
*/
public int getSuperclassNameIndex() { return superclass_name_index; }
static {
// Debugging ... on/off
//String debug = System.getProperty("JavaClass.debug");
//if(debug != null)
// JavaClass.debug = new Boolean(debug).booleanValue();
// Get path separator either / or \ usually
JavaClass.sep = java.io.File.separatorChar;
}
/**
* @param attributes.
*/
public void setAttributes(Attribute[] attributes) {
this.attributes = attributes;
}
/**
* @param class_name.
*/
public void setClassName(String class_name) {
this.class_name = class_name;
}
/**
* @param class_name_index.
*/
public void setClassNameIndex(int class_name_index) {
this.class_name_index = class_name_index;
}
/**
* @param constant_pool.
*/
public void setConstantPool(ConstantPool constant_pool) {
this.constant_pool = constant_pool;
}
/**
* @param fields.
*/
public void setFields(Field[] fields) {
this.fields = fields;
}
/**
* Set File name of class, aka SourceFile attribute value
*/
public void setFileName(String file_name) {
this.file_name = file_name;
}
/**
* @param interface_names.
*/
public void setInterfaceNames(String[] interface_names) {
this.interface_names = interface_names;
}
/**
* @param interfaces.
*/
public void setInterfaces(int[] interfaces) {
this.interfaces = interfaces;
}
/**
* @param major.
*/
public void setMajor(int major) {
this.major = major;
}
/**
* @param methods.
*/
public void setMethods(Method[] methods) {
this.methods = methods;
}
/**
* @param minor.
*/
public void setMinor(int minor) {
this.minor = minor;
}
/**
* Set absolute path to file this class was read from.
*/
public void setSourceFileName(String source_file_name) {
this.source_file_name = source_file_name;
}
/**
* @param superclass_name.
*/
public void setSuperclassName(String superclass_name) {
this.superclass_name = superclass_name;
}
/**
* @param superclass_name_index.
*/
public void setSuperclassNameIndex(int superclass_name_index) {
this.superclass_name_index = superclass_name_index;
}
/**
* @return String representing class contents.
*/
public String toString() {
String access = Utility.accessToString(access_flags, true);
access = access.equals("")? "" : (access + " ");
StringBuffer buf = new StringBuffer(access +
Utility.classOrInterface(access_flags) +
" " +
class_name + " extends " +
Utility.compactClassName(superclass_name,
false) + '\n');
int size = interfaces.length;
if(size > 0) {
buf.append("implements\t\t");
for(int i=0; i < size; i++) {
buf.append(interface_names[i]);
if(i < size - 1)
buf.append(", ");
}
buf.append('\n');
}
buf.append("filename\t\t" + file_name + '\n');
buf.append("compiled from\t\t" + source_file_name + '\n');
buf.append("compiler version\t" + major + "." + minor + '\n');
buf.append("access flags\t\t" + access_flags + '\n');
buf.append("constant pool\t\t" + constant_pool.getLength() + " entries\n");
buf.append("ACC_SUPER flag\t\t" + isSuper() + "\n");
if(attributes.length > 0) {
buf.append("\nAttribute(s):\n");
for(int i=0; i < attributes.length; i++)
buf.append(indent(attributes[i]));
}
if(fields.length > 0) {
buf.append("\n" + fields.length + " fields:\n");
for(int i=0; i < fields.length; i++)
buf.append("\t" + fields[i] + '\n');
}
if(methods.length > 0) {
buf.append("\n" + methods.length + " methods:\n");
for(int i=0; i < methods.length; i++)
buf.append("\t" + methods[i] + '\n');
}
return buf.toString();
}
private static final String indent(Object obj) {
StringTokenizer tok = new StringTokenizer(obj.toString(), "\n");
StringBuffer buf = new StringBuffer();
while(tok.hasMoreTokens())
buf.append("\t" + tok.nextToken() + "\n");
return buf.toString();
}
/**
* @return deep copy of this class
*/
public JavaClass copy() {
JavaClass c = null;
try {
c = (JavaClass)clone();
} catch(CloneNotSupportedException e) {}
c.constant_pool = constant_pool.copy();
c.interfaces = (int[])interfaces.clone();
c.interface_names = (String[])interface_names.clone();
c.fields = new Field[fields.length];
for(int i=0; i < fields.length; i++)
c.fields[i] = fields[i].copy(c.constant_pool);
c.methods = new Method[methods.length];
for(int i=0; i < methods.length; i++)
c.methods[i] = methods[i].copy(c.constant_pool);
c.attributes = new Attribute[attributes.length];
for(int i=0; i < attributes.length; i++)
c.attributes[i] = attributes[i].copy(c.constant_pool);
return c;
}
public final boolean instanceOf(JavaClass super_class) {
return Repository.instanceOf(this, super_class);
}
public final boolean isSuper() {
return (access_flags & Constants.ACC_SUPER) != 0;
}
public final boolean isClass() {
return (access_flags & Constants.ACC_INTERFACE) == 0;
}
/** @return returns either HEAP (generated), FILE, or ZIP
*/
public final byte getSource() {
return source;
}
}