| /* 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 |
| // ---------------------------------------------------------------------------- |
