/* Copyright (C) 2003 Vladimir Roubtsov. All rights reserved.
*
* This program and the accompanying materials are made available under
* the terms of the Common Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/cpl-v10.html
*
* $Id: ClassDef.java,v 1.1.1.1.2.1 2004/07/16 23:32:30 vlad_r Exp $
*/
package com.vladium.jcd.cls;
import java.io.DataOutputStream;
import java.io.IOException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import com.vladium.jcd.cls.attribute.AttributeElementFactory;
import com.vladium.jcd.cls.attribute.Attribute_info;
import com.vladium.jcd.cls.attribute.CodeAttribute_info;
import com.vladium.jcd.cls.attribute.InnerClassesAttribute_info;
import com.vladium.jcd.cls.constant.CONSTANT_Class_info;
import com.vladium.jcd.cls.constant.CONSTANT_Fieldref_info;
import com.vladium.jcd.cls.constant.CONSTANT_NameAndType_info;
import com.vladium.jcd.cls.constant.CONSTANT_String_info;
import com.vladium.jcd.cls.constant.CONSTANT_Utf8_info;
import com.vladium.jcd.compiler.IClassFormatOutput;
import com.vladium.jcd.lib.Types;
import com.vladium.jcd.lib.UDataOutputStream;
import com.vladium.util.ByteArrayOStream;
// ----------------------------------------------------------------------------
/**
* This class represents the abstract syntax table (AST) that {@link com.vladium.jcd.parser.ClassDefParser}
* produces from bytecode. Most elements are either settable or extendible.
* This class also implements {@link com.vladium.jcd.compiler.IClassFormatOutput}
* and works with {@link com.vladium.jcd.compiler.ClassWriter} to produce
* bytecode without an external compiler.<P>
*
* MT-safety: this class and all interfaces used by it are not safe for
* access from multiple concurrent threads.
*
* @author (C) 2001, Vlad Roubtsov
*/
public
final class ClassDef implements Cloneable, IAccessFlags, IClassFormatOutput
{
// public: ................................................................
public ClassDef ()
{
m_version = new int [2];
m_constants = ElementFactory.newConstantCollection (-1);
m_interfaces = ElementFactory.newInterfaceCollection (-1);
m_fields = ElementFactory.newFieldCollection (-1);
m_methods = ElementFactory.newMethodCollection (-1);
m_attributes = ElementFactory.newAttributeCollection (-1);
}
// Visitor:
public void accept (final IClassDefVisitor visitor, final Object ctx)
{
visitor.visit (this, ctx);
}
public long getMagic ()
{
return m_magic;
}
public void setMagic (final long magic)
{
m_magic = magic;
}
public int [] getVersion ()
{
return m_version;
}
public void setVersion (final int [] version)
{
m_version [0] = version [0];
m_version [1] = version [1];
}
public final void setDeclaredSUID (final long suid)
{
m_declaredSUID = suid;
}
public int getThisClassIndex ()
{
return m_this_class_index;
}
public void setThisClassIndex (final int this_class_index)
{
m_this_class_index = this_class_index;
}
public CONSTANT_Class_info getThisClass ()
{
return (CONSTANT_Class_info) m_constants.get (m_this_class_index);
}
public CONSTANT_Class_info getSuperClass ()
{
return (CONSTANT_Class_info) m_constants.get (m_super_class_index);
}
public String getName ()
{
return getThisClass ().getName (this);
}
public int getSuperClassIndex ()
{
return m_super_class_index;
}
public void setSuperClassIndex (final int super_class_index)
{
m_super_class_index = super_class_index;
}
// IAccessFlags:
public final int getAccessFlags ()
{
return m_access_flags;
}
public final void setAccessFlags (final int flags)
{
m_access_flags = flags;
}
public boolean isInterface ()
{
return (m_access_flags & ACC_INTERFACE) != 0;
}
public boolean isSynthetic ()
{
return m_attributes.hasSynthetic ();
}
public boolean isNested (final int [] nestedAccessFlags)
{
final InnerClassesAttribute_info innerClassesAttribute = m_attributes.getInnerClassesAttribute ();
if (innerClassesAttribute == null)
return false;
else
return innerClassesAttribute.makesClassNested (m_this_class_index, nestedAccessFlags);
}
// methods for getting various nested tables:
public IConstantCollection getConstants ()
{
return m_constants;
}
public IInterfaceCollection getInterfaces ()
{
return m_interfaces;
}
public IFieldCollection getFields ()
{
return m_fields;
}
public IMethodCollection getMethods ()
{
return m_methods;
}
public IAttributeCollection getAttributes ()
{
return m_attributes;
}
public int [] getFields (final String name)
{
return m_fields.get (this, name);
}
public int [] getMethods (final String name)
{
return m_methods.get (this, name);
}
// Cloneable:
/**
* Performs a deep copy.
*/
public Object clone ()
{
try
{
final ClassDef _clone = (ClassDef) super.clone ();
// do deep copy:
_clone.m_version = (int []) m_version.clone ();
_clone.m_constants = (IConstantCollection) m_constants.clone ();
_clone.m_interfaces = (IInterfaceCollection) m_interfaces.clone ();
_clone.m_fields = (IFieldCollection) m_fields.clone ();
_clone.m_methods = (IMethodCollection) m_methods.clone ();
_clone.m_attributes = (IAttributeCollection) m_attributes.clone ();
return _clone;
}
catch (CloneNotSupportedException e)
{
throw new InternalError (e.toString ());
}
}
// IClassFormatOutput:
public void writeInClassFormat (final UDataOutputStream out) throws IOException
{
if (out == null) throw new IllegalArgumentException ("null input: out");
out.writeU4 (m_magic);
out.writeU2 (m_version [1]);
out.writeU2 (m_version [0]);
m_constants.writeInClassFormat (out);
out.writeU2 (m_access_flags);
out.writeU2 (m_this_class_index);
out.writeU2 (m_super_class_index);
m_interfaces.writeInClassFormat (out);
m_fields.writeInClassFormat (out);
m_methods.writeInClassFormat (out);
m_attributes.writeInClassFormat (out);
}
public final long getDeclaredSUID ()
{
return m_declaredSUID;
}
/**
* This follows the spec at http://java.sun.com/j2se/1.4.1/docs/guide/serialization/spec/class.doc6.html#4100
* as well as undocumented hacks used by Sun's 1.4.2 J2SDK
*/
public final long computeSUID (final boolean skipCLINIT)
{
long result = m_declaredSUID;
if (result != 0L)
return result;
else
{
try
{
final ByteArrayOStream bout = new ByteArrayOStream (1024); // TODO: reuse these
final DataOutputStream dout = new DataOutputStream (bout);
// (1) The class name written using UTF encoding:
dout.writeUTF (Types.vmNameToJavaName (getName ())); // [in Java format]
// (2) The class modifiers written as a 32-bit integer:
// ACC_STATIC is never written for nested classes/interfaces;
// however, ACC_SUPER must be ignored:
{
// this is tricky: for static/non-static nested classes that
// were declared protected in the source the usual access flags
// will have ACC_PUBLIC set; the only way to achieve J2SDK
// compatibility is to recover the source access flags
// from the InnerClasses attribute:
final int [] nestedAccessFlags = new int [1];
final int modifiers = (isNested (nestedAccessFlags)
? nestedAccessFlags [0]
: getAccessFlags ())
& (ACC_PUBLIC | ACC_FINAL | ACC_INTERFACE | ACC_ABSTRACT);
// if/when emma decides to instrument interfaces for <clinit>
// coverage, compensate for javac bug in which ABSTRACT bit
// was set for an interface only if the interface declared methods
// [Sun's J2SDK]:
dout.writeInt (modifiers);
}
// not doing another J2SDK compensation for arrays, because
// we never load/instrument those
// (3) The name of each interface sorted by name written using UTF encoding
{
final IInterfaceCollection interfaces = getInterfaces ();
final String [] ifcs = new String [interfaces.size ()];
final int iLimit = ifcs.length;
for (int i = 0; i < iLimit; ++ i)
{
// [in Java format]
ifcs [i] = Types.vmNameToJavaName (((CONSTANT_Class_info) m_constants.get (interfaces.get (i))).getName (this));
}
Arrays.sort (ifcs);
for (int i = 0; i < iLimit; ++ i)
{
dout.writeUTF (ifcs [i]);
}
}
// (4) For each field of the class sorted by field name (except
// private static and private transient fields):
// a. The name of the field in UTF encoding.
// b. The modifiers of the field written as a 32-bit integer.
// c. The descriptor of the field in UTF encoding
{
final IFieldCollection fields = getFields ();
final FieldDescriptor [] fds = new FieldDescriptor [fields.size ()];
int fcount = 0;
for (int f = 0, fLimit = fds.length; f < fLimit; ++ f)
{
final Field_info field = fields.get (f);
final int modifiers = field.getAccessFlags ();
if (((modifiers & ACC_PRIVATE) == 0) ||
((modifiers & (ACC_STATIC | ACC_TRANSIENT)) == 0))
fds [fcount ++] = new FieldDescriptor (field.getName (this), modifiers, field.getDescriptor (this));
}
if (fcount > 0)
{
Arrays.sort (fds, 0, fcount);
for (int i = 0; i < fcount; ++ i)
{
final FieldDescriptor fd = fds [i];
dout.writeUTF (fd.m_name);
dout.writeInt (fd.m_modifiers);
dout.writeUTF (fd.m_descriptor);
}
}
}
// (5) If a class initializer exists, write out the following:
// a. The name of the method, <clinit>, in UTF encoding.
// b. The modifier of the method, ACC_STATIC, written as a 32-bit integer.
// c. The descriptor of the method, ()V, in UTF encoding.
// (6) For each non-private constructor sorted by method name and signature:
// a. The name of the method, <init>, in UTF encoding.
// b. The modifiers of the method written as a 32-bit integer.
// c. The descriptor of the method in UTF encoding.
// (7) For each non-private method sorted by method name and signature:
// a. The name of the method in UTF encoding.
// b. The modifiers of the method written as a 32-bit integer.
// c. The descriptor of the method in UTF encoding.
// note: although this is not documented, J2SDK code uses '.''s as
// descriptor separators (this is done for methods only, not for fields)
{
final IMethodCollection methods = getMethods ();
boolean hasCLINIT = false;
final ConstructorDescriptor [] cds = new ConstructorDescriptor [methods.size ()];
final MethodDescriptor [] mds = new MethodDescriptor [cds.length];
int ccount = 0, mcount = 0;
for (int i = 0, iLimit = cds.length; i < iLimit; ++ i)
{
final Method_info method = methods.get (i);
final String name = method.getName (this);
if (! hasCLINIT && IClassDefConstants.CLINIT_NAME.equals (name))
{
hasCLINIT = true;
continue;
}
else
{
final int modifiers = method.getAccessFlags ();
if ((modifiers & ACC_PRIVATE) == 0)
{
if (IClassDefConstants.INIT_NAME.equals (name))
cds [ccount ++] = new ConstructorDescriptor (modifiers, method.getDescriptor (this));
else
mds [mcount ++] = new MethodDescriptor (name, modifiers, method.getDescriptor (this));
}
}
}
if (hasCLINIT && ! skipCLINIT)
{
dout.writeUTF (IClassDefConstants.CLINIT_NAME);
dout.writeInt (ACC_STATIC);
dout.writeUTF (IClassDefConstants.CLINIT_DESCRIPTOR);
}
if (ccount > 0)
{
Arrays.sort (cds, 0, ccount);
for (int i = 0; i < ccount; ++ i)
{
final ConstructorDescriptor cd = cds [i];
dout.writeUTF (IClassDefConstants.INIT_NAME);
dout.writeInt (cd.m_modifiers);
dout.writeUTF (cd.m_descriptor.replace ('/', '.'));
}
}
if (mcount > 0)
{
Arrays.sort (mds, 0, mcount);
for (int i = 0; i < mcount; ++ i)
{
final MethodDescriptor md = mds [i];
dout.writeUTF (md.m_name);
dout.writeInt (md.m_modifiers);
dout.writeUTF (md.m_descriptor.replace ('/', '.'));
}
}
}
dout.flush();
if (DEBUG_SUID)
{
byte [] dump = bout.copyByteArray ();
for (int x = 0; x < dump.length; ++ x)
{
System.out.println ("DUMP[" + x + "] = " + dump [x] + "\t" + (char) dump[x]);
}
}
final MessageDigest md = MessageDigest.getInstance ("SHA");
md.update (bout.getByteArray (), 0, bout.size ());
final byte [] hash = md.digest ();
if (DEBUG_SUID)
{
for (int x = 0; x < hash.length; ++ x)
{
System.out.println ("HASH[" + x + "] = " + hash [x]);
}
}
// final int hash0 = hash [0];
// final int hash1 = hash [1];
// result = ((hash0 >>> 24) & 0xFF) | ((hash0 >>> 16) & 0xFF) << 8 | ((hash0 >>> 8) & 0xFF) << 16 | ((hash0 >>> 0) & 0xFF) << 24 |
// ((hash1 >>> 24) & 0xFF) << 32 | ((hash1 >>> 16) & 0xFF) << 40 | ((hash1 >>> 8) & 0xFF) << 48 | ((hash1 >>> 0) & 0xFF) << 56;
for (int i = Math.min (hash.length, 8) - 1; i >= 0; -- i)
{
result = (result << 8) | (hash [i] & 0xFF);
}
return result;
}
catch (IOException ioe)
{
throw new Error (ioe.getMessage ());
}
catch (NoSuchAlgorithmException nsae)
{
throw new SecurityException (nsae.getMessage());
}
}
}
public int addCONSTANT_Utf8 (final String value, final boolean keepUnique)
{
if (keepUnique)
{
final int existing = m_constants.findCONSTANT_Utf8 (value);
if (existing > 0)
{
return existing;
}
// [else fall through]
}
return m_constants.add (new CONSTANT_Utf8_info (value));
}
public int addStringConstant (final String value)
{
final int value_index = addCONSTANT_Utf8 (value, true);
// TODO: const uniqueness
return m_constants.add (new CONSTANT_String_info (value_index));
}
public int addNameType (final String name, final String typeDescriptor)
{
final int name_index = addCONSTANT_Utf8 (name, true);
final int descriptor_index = addCONSTANT_Utf8 (typeDescriptor, true);
return m_constants.add (new CONSTANT_NameAndType_info (name_index, descriptor_index));
}
public int addClassref (final String classJVMName)
{
final int name_index = addCONSTANT_Utf8 (classJVMName, true);
// TODO: this should do uniqueness checking:
return m_constants.add (new CONSTANT_Class_info (name_index));
}
/**
* Adds a new declared field to this class [with no attributes]
*/
public int addField (final String name, final String descriptor, final int access_flags)
{
// TODO: support Fields with initializer attributes?
// TODO: no "already exists" check done here
final int name_index = addCONSTANT_Utf8 (name, true);
final int descriptor_index = addCONSTANT_Utf8 (descriptor, true);
final Field_info field = new Field_info (access_flags, name_index, descriptor_index,
ElementFactory.newAttributeCollection (0));
return m_fields.add (field);
}
/**
* Adds a new declared field to this class [with given attributes]
*/
public int addField (final String name, final String descriptor, final int access_flags,
final IAttributeCollection attributes)
{
// TODO: support Fields with initializer attributes?
// TODO: no "already exists" check done here
final int name_index = addCONSTANT_Utf8 (name, true);
final int descriptor_index = addCONSTANT_Utf8 (descriptor, true);
final Field_info field = new Field_info (access_flags, name_index, descriptor_index, attributes);
return m_fields.add (field);
}
// TODO: rework this API
public Method_info newEmptyMethod (final String name, final String descriptor, final int access_flags)
{
// TODO: flag for making synthetic etc
final int attribute_name_index = addCONSTANT_Utf8 (Attribute_info.ATTRIBUTE_CODE, true);
final int name_index = addCONSTANT_Utf8 (name, true);
final int descriptor_index = addCONSTANT_Utf8 (descriptor, true);
final IAttributeCollection attributes = ElementFactory.newAttributeCollection (0);
final CodeAttribute_info code = new CodeAttribute_info (attribute_name_index, 0, 0,
CodeAttribute_info.EMPTY_BYTE_ARRAY,
AttributeElementFactory.newExceptionHandlerTable (0),
ElementFactory.newAttributeCollection (0));
attributes.add (code);
final Method_info method = new Method_info (access_flags, name_index, descriptor_index, attributes);
return method;
}
public int addMethod (final Method_info method)
{
return m_methods.add (method);
}
/**
* Adds a reference to a field declared by this class.
*
* @return constant pool index of the reference
*/
public int addFieldref (final Field_info field)
{
// TODO: keepUnique flag
final CONSTANT_NameAndType_info nametype = new CONSTANT_NameAndType_info (field.m_name_index, field.m_descriptor_index);
final int nametype_index = m_constants.add (nametype); // TODO: unique logic
return m_constants.add (new CONSTANT_Fieldref_info (m_this_class_index, nametype_index));
}
/**
* Adds a reference to a field declared by this class.
*
* @return constant pool index of the reference
*/
public int addFieldref (final int offset)
{
// TODO: keepUnique flag
final Field_info field = m_fields.get (offset);
final CONSTANT_NameAndType_info nametype = new CONSTANT_NameAndType_info (field.m_name_index, field.m_descriptor_index);
final int nametype_index = m_constants.add (nametype); // TODO: unique logic
return m_constants.add (new CONSTANT_Fieldref_info (m_this_class_index, nametype_index));
}
// protected: .............................................................
// package: ...............................................................
// private: ...............................................................
private static final class FieldDescriptor implements Comparable
{
// Comparable:
public final int compareTo (final Object obj)
{
return m_name.compareTo (((FieldDescriptor) obj).m_name);
}
FieldDescriptor (final String name, final int modifiers, final String descriptor)
{
m_name = name;
m_modifiers = modifiers;
m_descriptor = descriptor;
}
final String m_name;
final int m_modifiers;
final String m_descriptor;
} // end of nested class
private static final class ConstructorDescriptor implements Comparable
{
// Comparable:
public final int compareTo (final Object obj)
{
return m_descriptor.compareTo (((ConstructorDescriptor) obj).m_descriptor);
}
ConstructorDescriptor (final int modifiers, final String descriptor)
{
m_modifiers = modifiers;
m_descriptor = descriptor;
}
final int m_modifiers;
final String m_descriptor;
} // end of nested class
private static final class MethodDescriptor implements Comparable
{
// Comparable:
public final int compareTo (final Object obj)
{
final MethodDescriptor rhs = (MethodDescriptor) obj;
int result = m_name.compareTo (rhs.m_name);
if (result == 0)
result = m_descriptor.compareTo (rhs.m_descriptor);
return result;
}
MethodDescriptor (final String name, final int modifiers, final String descriptor)
{
m_name = name;
m_modifiers = modifiers;
m_descriptor = descriptor;
}
final String m_name;
final int m_modifiers;
final String m_descriptor;
} // end of nested class
// TODO: final fields
private long m_magic;
private int [] /* major, minor */ m_version;
private int m_access_flags;
private int m_this_class_index, m_super_class_index;
private IConstantCollection m_constants;
private IInterfaceCollection m_interfaces;
private IFieldCollection m_fields;
private IMethodCollection m_methods;
private IAttributeCollection m_attributes;
private long m_declaredSUID;
private static final boolean DEBUG_SUID = false;
} // end of class
// ----------------------------------------------------------------------------
|
