/* 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: CodeAttribute_info.java,v 1.1.1.1 2004/05/09 16:57:47 vlad_r Exp $
*/
package com.vladium.jcd.cls.attribute;
import java.io.IOException;
import com.vladium.jcd.cls.ElementFactory;
import com.vladium.jcd.cls.IAttributeCollection;
import com.vladium.jcd.cls.IConstantCollection;
import com.vladium.jcd.lib.UDataInputStream;
import com.vladium.jcd.lib.UDataOutputStream;
// ----------------------------------------------------------------------------
/**
* The Code attribute is a variable-length attribute used in the attributes
* table of {@link com.vladium.jcd.cls.Method_info} structures. A Code attribute
* contains the JVM instructions and auxiliary information for a single Java method,
* instance initialization method, or class or interface initialization method.
* Every Java Virtual Machine implementation must recognize Code attributes. There
* must be exactly one Code attribute in each method_info structure.<P>
*
* The Code attribute has the format
* <PRE>
* Code_attribute {
* u2 attribute_name_index;
* u4 attribute_length;
* u2 max_stack;
* u2 max_locals;
* u4 code_length;
* u1 code[code_length];
* u2 exception_table_length;
* { u2 start_pc;
* u2 end_pc;
* u2 handler_pc;
* u2 catch_type;
* } exception_table[exception_table_length];
*
* u2 attributes_count;
* attribute_info attributes[attributes_count];
* }
* </PRE>
*
* The value of the max_stack item gives the maximum number of words on the operand
* stack at any point during execution of this method.<P>
*
* The value of the max_locals item gives the number of local variables used by this
* method, including the parameters passed to the method on invocation. The index of
* the first local variable is 0 . The greatest local variable index for a one-word
* value is max_locals-1 . The greatest local variable index for a two-word value is
* max_locals-2.<P>
*
* The value of the code_length item gives the number of bytes in the code array for
* this method. The value of code_length must be greater than zero; the code array must
* not be empty.The code array gives the actual bytes of Java Virtual Machine code that
* implement the method.<P>
*
* The value of the exception_table_length item gives the number of entries in the
* exception_table table. Each entry in the exception_table array describes one
* exception handler in the code array: see {@link Exception_info}.<P>
*
* The value of the attributes_count item indicates the number of attributes of the Code
* attribute. Each value of the attributes table must be a variable-length attribute
* structure. A Code attribute can have any number of optional attributes associated
* with it.
*
* @author (C) 2001, Vlad Roubtsov
*/
public
final class CodeAttribute_info extends Attribute_info
{
// public: ................................................................
public static final byte [] EMPTY_BYTE_ARRAY = new byte [0];
public int m_max_stack, m_max_locals;
public CodeAttribute_info (final int attribute_name_index,
final int max_stack, int max_locals,
final byte [] code,
final IExceptionHandlerTable exceptionHandlerTable,
final IAttributeCollection attributes)
{
super (attribute_name_index, 8 + (code != null ? code.length : 0) + exceptionHandlerTable.length () + attributes.length ());
m_max_stack = max_stack;
m_max_locals = max_locals;
m_code = (code != null ? code : EMPTY_BYTE_ARRAY);
m_codeSize = m_code.length;
m_exceptionHandlerTable = exceptionHandlerTable;
m_attributes = attributes;
}
/**
* NOTE: must also use getCodeSize()
* @return
*/
public final byte [] getCode ()
{
return m_code;
}
public final int getCodeSize ()
{
return m_codeSize;
}
public IAttributeCollection getAttributes ()
{
return m_attributes;
}
public IExceptionHandlerTable getExceptionTable ()
{
return m_exceptionHandlerTable;
}
public long length ()
{
return 14 + m_codeSize + m_exceptionHandlerTable.length () + m_attributes.length ();
}
// Visitor:
public void accept (final IAttributeVisitor visitor, final Object ctx)
{
visitor.visit (this, ctx);
}
public String toString ()
{
String eol = System.getProperty ("line.separator");
StringBuffer s = new StringBuffer ();
s.append ("CodeAttribute_info: [attribute_name_index = " + m_name_index + ", attribute_length = " + m_attribute_length + "]" + eol);
s.append (" max_stack/max_locals = " + m_max_stack + '/' + m_max_locals + eol);
s.append (" code [length " + m_codeSize + "]" + eol);
for (int a = 0; a < m_attributes.size (); ++ a)
{
s.append (" " + m_attributes.get (a) + eol);
}
return s.toString ();
}
// Cloneable:
/**
* Performs a deep copy.
*/
public Object clone ()
{
final CodeAttribute_info _clone = (CodeAttribute_info) super.clone ();
// do deep copy:
_clone.m_code = (m_codeSize == 0 ? EMPTY_BYTE_ARRAY : (byte []) m_code.clone ()); // does not trim
_clone.m_exceptionHandlerTable = (IExceptionHandlerTable) m_exceptionHandlerTable.clone ();
_clone.m_attributes = (IAttributeCollection) m_attributes.clone ();
return _clone;
}
// IClassFormatOutput:
public void writeInClassFormat (final UDataOutputStream out) throws IOException
{
super.writeInClassFormat (out);
out.writeU2 (m_max_stack);
out.writeU2 (m_max_locals);
out.writeU4 (m_codeSize);
out.write (m_code, 0, m_codeSize); // TODO: THIS IS WRONG
m_exceptionHandlerTable.writeInClassFormat (out);
m_attributes.writeInClassFormat (out);
}
public void setCode (final byte [] code, final int codeSize)
{
m_code = code;
m_codeSize = codeSize;
}
// protected: .............................................................
// package: ...............................................................
CodeAttribute_info (final IConstantCollection constants,
final int attribute_name_index, final long attribute_length,
final UDataInputStream bytes)
throws IOException
{
super (attribute_name_index, attribute_length);
m_max_stack = bytes.readU2 ();
m_max_locals = bytes.readU2 ();
final long code_length = bytes.readU4 ();
m_code = new byte [(int) code_length];
bytes.readFully (m_code);
m_codeSize = (int) code_length;
final int exception_table_length = bytes.readU2 ();
m_exceptionHandlerTable = AttributeElementFactory.newExceptionHandlerTable (exception_table_length);
for (int i = 0; i < exception_table_length; ++ i)
{
Exception_info exception_info = new Exception_info (bytes);
if (DEBUG) System.out.println ("\t[" + i + "] exception: " + exception_info);
m_exceptionHandlerTable.add (exception_info);
}
// TODO: put this logic into AttributeCollection
final int attributes_count = bytes.readU2 ();
m_attributes = ElementFactory.newAttributeCollection (attributes_count);
for (int i = 0; i < attributes_count; ++ i)
{
Attribute_info attribute_info = Attribute_info.new_Attribute_info (constants, bytes);
if (DEBUG) System.out.println ("\t[" + i + "] attribute: " + attribute_info);
m_attributes.add (attribute_info);
}
}
// private: ...............................................................
private byte [] m_code; // never null [valid content extent is m_codeSize]
private int m_codeSize;
private IExceptionHandlerTable m_exceptionHandlerTable; // never null
private IAttributeCollection m_attributes; // never null
private static final boolean DEBUG = false;
} // end of class
// ----------------------------------------------------------------------------