com.tangosol.dev.assembler.ClassFile Maven / Gradle / Ivy
Show all versions of coherence Show documentation
/*
* Copyright (c) 2000, 2020, Oracle and/or its affiliates.
*
* Licensed under the Universal Permissive License v 1.0 as shown at
* http://oss.oracle.com/licenses/upl.
*/
package com.tangosol.dev.assembler;
import java.io.IOException;
import java.io.EOFException;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Enumeration;
import com.tangosol.io.ByteArrayReadBuffer;
import com.tangosol.io.ReadBuffer;
import com.tangosol.util.StringTable;
/**
* Represents a Java .class structure (the JVM Class file format). For
* reference purposes, download the JVM specification from
* http://java.sun.com/docs/index.html.
*
* Description:
*
* The .class structure is hierachical in nature with a single internally
* shared resource, the constant pool. In other words, with the exception
* of the constant pool, all portions of the .class structure only refer
* to themselves or structures which are contained within themselves. The
* hierarchy is as follows:
*
*
* 1) ClassFile
* 1) header
* 1) magic cookie
* 2) expected JVM version
* 2) Constant[] (the ConstantPool)
* 3) class information
* 1) AccessFlags
* 2) this class/interface identity
* 3) super class/interface identity
* 4) implemented interface identity[]
* 4) Field[]
* 1) AccessFlags
* 2) field identity
* 3) field data type
* 4) Attribute[]
* 1) JVM supports a single "ConstantValue" attribute
* 5) Method[]
* 1) AccessFlags
* 2) method identity
* 3) method parameter/return signature
* 4) Attribute[]
* 1) JVM supports a single "Code" attribute
* 1) frame stack area size
* 2) frame local variable area size
* 3) Op[]
* 4) TryCatch[]
* 1) Op "try" range [pc,pc)
* 2) Handler pc
* 3) catchable class identity
* 5) Attribute[] (yes, the "Code" attribute has attributes!)
* 1) JVM supports a single "LineNumberTable" attribute
* - cross-references pc and source line number
* values
* 2) JVM supports a single "LocalVariableTable" attribute
* - cross-references local variable index and local
* variable name/data type values
* 3) JVM supports a single "LocalVariableTypeTable" attribute
* - cross-references local variable index and local
* variable name/data signature values
* 2) JVM supports a single "Exceptions" attribute
* 1) declared exception identity[]
* 6) Attribute[]
* 1) JVM specification defines (but JVM does not support) a single
* "SourceFile" attribute
* - specifies the OS source file name (without any path)
*
*
* WARNING!!! Other attributes have been introduced since the specification
* was last updated. These attributes are similar in structure and naming
* conventions to the current attributes and appear to all be related to the
* JDK1.1 "inner class" feature.
*
* Note: Other attributes than those defined above are legal but ignored
* by both the JVM and any other process examining/manipulating/using a
* .class structure. Custom-defined attributes must follow the package
* and class naming conventions, e.g. "com.tangosol.examples.BreakPointTable".
*
* Requirements:
*
*
* 1) The role of the class is to support the contruction, reflection,
* modification, and transport (i.e. transient storage) of Java
* ClassFile (aka ".class file") structures
*
* 1) An assembler will construct ClassFile structures
*
* 2) The Component Definition will create JCS structures and a
* disassembler will display detailed information using the
* reflection information provided by ClassFile structures
*
* 3) A deployment tool or the class loader will patch up package
* names by modifying the ClassFile structure
*
* 4) ClassFile structures provide a type-safe reference type for
* compiled classes (typically used for passing a compiled class
* as a parameter or as the type of a return value)
*
* 2) Efficiency, especially when the ClassFile structure is used only
* for transport, means that the disassembly of .class structures and
* the final assembly and linking of accessor-supplied information must
* be deferred until necessary
*
* 3) Production of dependency and relationship information which would
* enable partial compilation, selective re-compilation, BOM/where-used
* and impact analysis
*
* 4) Support for partial, incremental, and method (re-)compilation
*
*
* WARNING!!! This implementation is not intended to be thread-safe. Do
* not access a single instance of this class (or any of the other classes
* in this package) from more than one thread unless synchronization is
* handled by the caller.
*
* WARNING!!! This implementation is not intended to be idiot-safe. It is
* the responsibility of the caller to provide legal ClassFile information,
* and not the responsibility of this implementation to detect it.
*
* @version 0.10, 02/05/98, prototype dis-assembler
* @version 0.50, 05/07/98, assembler/dis-assembler
* @author Cameron Purdy
*/
public class ClassFile extends VMStructure implements Constants
{
// ----- construction ---------------------------------------------------
/**
* Construct a new ClassFile object.
*
* @param sThis fully qualified name of this class
* @param sSuper name of the super class, or null if there is no
* super class (e.g. java.lang.Object or an interface)
* @param fInterface true means that this is an interface
*/
public ClassFile(String sThis, String sSuper, boolean fInterface)
{
init();
setLoaded(true);
setName(sThis);
setSuper(sSuper);
setInterface(fInterface);
setSynchronized(true);
}
/**
* Constructs a ClassFile from a .class structure stored in a byte array.
*
* This constructor is preferred to the DataInput-based constructor.
*
* @param abClazz the byte array containing the .class structure
*/
public ClassFile(byte[] abClazz)
{
setBytes(abClazz);
}
/**
* Constructs a ClassFile from a stream containing a .class structure.
*
* @param stream the java.io.DataInput stream containing the .class
* structure
*/
public ClassFile(DataInput stream)
throws IOException
{
load(stream);
}
// ----- persistence ----------------------------------------------------
/**
* Read the .class structure out of the passed stream.
*
* @param stream the object implementing java.io.DataInput and containing
* the .class structure
*
* @throws java.io.IOException if an error (besides EOF) occurs reading
* from the stream
*/
public void load(DataInput stream)
throws IOException
{
final int MAX = 8192;
byte[] abBuf = new byte[MAX];
ByteArrayOutputStream streamRaw = new ByteArrayOutputStream(MAX);
int of = 0;
try
{
while (true)
{
byte b = stream.readByte();
abBuf[of++] = b;
if (of == MAX)
{
streamRaw.write(abBuf, 0, MAX);
of = 0;
}
}
}
catch (EOFException e)
{
if (of > 0)
{
streamRaw.write(abBuf, 0, of);
}
}
setBytes(streamRaw.toByteArray());
}
/**
* Write the .class structure into a stream.
*
* @param stream the object implementing java.io.DataOutput to which
* the .class structure will be written
*
* @throws java.io.IOException if an error occurs writing the stream
*/
public void save(DataOutput stream)
throws IOException
{
stream.write(getBytes());
}
// ----- VMStructure operations -----------------------------------------
/**
* The disassembly process reads the structure from the passed input
* stream and uses the constant pool to dereference any constant
* references.
*
* The structure is defined by the Java Virtual Machine Specification as:
*
* ClassFile
* {
* u4 magic;
* u2 minor_version;
* u2 major_version;
* u2 constant_pool_count;
* cp_info constant_pool[constant_pool_count-1];
* u2 access_flags;
* u2 this_class;
* u2 super_class;
* u2 interfaces_count;
* u2 interfaces[interfaces_count];
* u2 fields_count;
* field_info fields[fields_count];
* u2 methods_count;
* method_info methods[methods_count];
* u2 attributes_count;
* attribute_info attributes[attributes_count];
* }
*
* The structure is defined by the Java Virtual Machine Specification as:
*
* ClassFile
* {
* u4 magic;
* u2 minor_version;
* u2 major_version;
* u2 constant_pool_count;
* cp_info constant_pool[constant_pool_count-1];
* u2 access_flags;
* u2 this_class;
* u2 super_class;
* u2 interfaces_count;
* u2 interfaces[interfaces_count];
* u2 fields_count;
* field_info fields[fields_count];
* u2 methods_count;
* method_info methods[methods_count];
* u2 attributes_count;
* attribute_info attributes[attributes_count];
* }
*