https://openjdk.java.net/ 
/*
 * reserved comment block
 * DO NOT REMOVE OR ALTER!
 */
/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.sun.org.apache.bcel.internal.classfile;


import  com.sun.org.apache.bcel.internal.Constants;
import  java.io.*;


This class represents a chunk of Java byte code contained in a
method. It is instantiated by the
Attribute.readAttribute() method. A Code
attribute contains informations about operand stack, local
variables, byte code and the exceptions handled within this
method.
This attribute has attributes itself, namely LineNumberTable which
is used for debugging purposes and LocalVariableTable which
contains information about the local variables.

Author: M. Dahm
See Also:
/**
 * This class represents a chunk of Java byte code contained in a
 * method. It is instantiated by the
 * <em>Attribute.readAttribute()</em> method. A <em>Code</em>
 * attribute contains informations about operand stack, local
 * variables, byte code and the exceptions handled within this
 * method.
 *
 * This attribute has attributes itself, namely <em>LineNumberTable</em> which
 * is used for debugging purposes and <em>LocalVariableTable</em> which
 * contains information about the local variables.
 *
 * @author  <A HREF="mailto:markus.dahm@berlin.de">M. Dahm</A>
 * @see     Attribute
 * @see     CodeException
 * @see     LineNumberTable
 * @see LocalVariableTable
 */
public final class Code extends Attribute {
  private int             max_stack;   // Maximum size of stack used by this method
  private int             max_locals;  // Number of local variables
  private int             code_length; // Length of code in bytes
  private byte[]          code;        // Actual byte code

  private int             exception_table_length;
  private CodeException[] exception_table;  // Table of handled exceptions
  private int             attributes_count; // Attributes of code: LineNumber
  private Attribute[]     attributes;       // or LocalVariable

  
Initialize from another object. Note that both objects use the same
references (shallow copy). Use copy() for a physical copy.

/**
   * Initialize from another object. Note that both objects use the same
   * references (shallow copy). Use copy() for a physical copy.
   */
  public Code(Code c) {
    this(c.getNameIndex(), c.getLength(), c.getMaxStack(), c.getMaxLocals(),
         c.getCode(), c.getExceptionTable(), c.getAttributes(),
         c.getConstantPool());
  }

  
Params:
  • name_index – Index pointing to the name Code
  • length – Content length in bytes
  • file – Input stream
  • constant_pool – Array of constants
/**
   * @param name_index Index pointing to the name <em>Code</em>
   * @param length Content length in bytes
   * @param file Input stream
   * @param constant_pool Array of constants
   */
  Code(int name_index, int length, DataInputStream file,
       ConstantPool constant_pool) throws IOException
  {
    // Initialize with some default values which will be overwritten later
    this(name_index, length,
         file.readUnsignedShort(), file.readUnsignedShort(),
         (byte[])null, (CodeException[])null, (Attribute[])null,
         constant_pool);

    code_length = file.readInt();
    code = new byte[code_length]; // Read byte code
    file.readFully(code);

    /* Read exception table that contains all regions where an exception
     * handler is active, i.e., a try { ... } catch() block.
     */
    exception_table_length = file.readUnsignedShort();
    exception_table        = new CodeException[exception_table_length];

    for(int i=0; i < exception_table_length; i++)
      exception_table[i] = new CodeException(file);

    /* Read all attributes, currently `LineNumberTable' and
     * `LocalVariableTable'
     */
    attributes_count = file.readUnsignedShort();
    attributes = new Attribute[attributes_count];
    for(int i=0; i < attributes_count; i++)
      attributes[i] = Attribute.readAttribute(file, constant_pool);

    /* Adjust length, because of setAttributes in this(), s.b.  length
     * is incorrect, because it didn't take the internal attributes
     * into account yet! Very subtle bug, fixed in 3.1.1.
     */
    this.length = length;
  }

  
Params:
  • name_index – Index pointing to the name Code
  • length – Content length in bytes
  • max_stack – Maximum size of stack
  • max_locals – Number of local variables
  • code – Actual byte code
  • exception_table – Table of handled exceptions
  • attributes – Attributes of code: LineNumber or LocalVariable
  • constant_pool – Array of constants
/**
   * @param name_index Index pointing to the name <em>Code</em>
   * @param length Content length in bytes
   * @param max_stack Maximum size of stack
   * @param max_locals Number of local variables
   * @param code Actual byte code
   * @param exception_table Table of handled exceptions
   * @param attributes Attributes of code: LineNumber or LocalVariable
   * @param constant_pool Array of constants
   */
  public Code(int name_index, int length,
              int max_stack,  int max_locals,
              byte[]          code,
              CodeException[] exception_table,
              Attribute[]     attributes,
              ConstantPool    constant_pool)
  {
    super(Constants.ATTR_CODE, name_index, length, constant_pool);

    this.max_stack         = max_stack;
    this.max_locals        = max_locals;

    setCode(code);
    setExceptionTable(exception_table);
    setAttributes(attributes); // Overwrites length!
  }

  
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.

Params:
  • v – Visitor object
/**
   * 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.visitCode(this);
  }

  
Dump code attribute to file stream in binary format.

Params:
  • file – Output file stream
Throws:
/**
   * Dump code attribute to file stream in binary format.
   *
   * @param file Output file stream
   * @throws IOException
   */
  public final void dump(DataOutputStream file) throws IOException
  {
    super.dump(file);

    file.writeShort(max_stack);
    file.writeShort(max_locals);
    file.writeInt(code_length);
    file.write(code, 0, code_length);

    file.writeShort(exception_table_length);
    for(int i=0; i < exception_table_length; i++)
      exception_table[i].dump(file);

    file.writeShort(attributes_count);
    for(int i=0; i < attributes_count; i++)
      attributes[i].dump(file);
  }

  
See Also:
Returns:Collection of code attributes.
/**
   * @return Collection of code attributes.
   * @see Attribute
   */
  public final Attribute[] getAttributes()         { return attributes; }

  
Returns:LineNumberTable of Code, if it has one
/**
   * @return LineNumberTable of Code, if it has one
   */
  public LineNumberTable getLineNumberTable() {
    for(int i=0; i < attributes_count; i++)
      if(attributes[i] instanceof LineNumberTable)
        return (LineNumberTable)attributes[i];

    return null;
  }

  
Returns:LocalVariableTable of Code, if it has one
/**
   * @return LocalVariableTable of Code, if it has one
   */
  public LocalVariableTable getLocalVariableTable() {
    for(int i=0; i < attributes_count; i++)
      if(attributes[i] instanceof LocalVariableTable)
        return (LocalVariableTable)attributes[i];

    return null;
  }

  
Returns:Actual byte code of the method.
/**
   * @return Actual byte code of the method.
   */
  public final byte[] getCode()      { return code; }

  
See Also:
Returns:Table of handled exceptions.
/**
   * @return Table of handled exceptions.
   * @see CodeException
   */
  public final CodeException[] getExceptionTable() { return exception_table; }

  
Returns:Number of local variables.
/**
   * @return Number of local variables.
   */
  public final int  getMaxLocals() { return max_locals; }

  
Returns:Maximum size of stack used by this method.
/**
   * @return Maximum size of stack used by this method.
   */

  public final int  getMaxStack()  { return max_stack; }

  
Returns:the internal length of this code attribute (minus the first 6 bytes)
and excluding all its attributes
/**
   * @return the internal length of this code attribute (minus the first 6 bytes)
   * and excluding all its attributes
   */
  private final int getInternalLength() {
    return 2 /*max_stack*/ + 2 /*max_locals*/ + 4 /*code length*/
      + code_length /*byte-code*/
      + 2 /*exception-table length*/
      + 8 * exception_table_length /* exception table */
      + 2 /* attributes count */;
  }

  
Returns:the full size of this code attribute, minus its first 6 bytes,
including the size of all its contained attributes
/**
   * @return the full size of this code attribute, minus its first 6 bytes,
   * including the size of all its contained attributes
   */
  private final int calculateLength() {
    int len = 0;

    for(int i=0; i < attributes_count; i++)
      len += attributes[i].length + 6 /*attribute header size*/;

    return len + getInternalLength();
  }

  
@paramattributes.
/**
   * @param attributes.
   */
  public final void setAttributes(Attribute[] attributes) {
    this.attributes  = attributes;
    attributes_count = (attributes == null)? 0 : attributes.length;
    length = calculateLength(); // Adjust length
  }

  
Params:
  • code – byte code
/**
   * @param code byte code
   */
  public final void setCode(byte[] code) {
    this.code   = code;
    code_length = (code == null)? 0 : code.length;
  }

  
Params:
  • exception_table – exception table
/**
   * @param exception_table exception table
   */
  public final void setExceptionTable(CodeException[] exception_table) {
    this.exception_table   = exception_table;
    exception_table_length = (exception_table == null)? 0 :
      exception_table.length;
  }

  
Params:
  • max_locals – maximum number of local variables
/**
   * @param max_locals maximum number of local variables
   */
  public final void setMaxLocals(int max_locals) {
    this.max_locals = max_locals;
  }

  
Params:
  • max_stack – maximum stack size
/**
   * @param max_stack maximum stack size
   */
  public final void setMaxStack(int max_stack) {
    this.max_stack = max_stack;
  }

  
Returns:String representation of code chunk.
/**
   * @return String representation of code chunk.
   */
  public final String toString(boolean verbose) {
    StringBuffer buf;

    buf = new StringBuffer("Code(max_stack = " + max_stack +
                           ", max_locals = " + max_locals +
                           ", code_length = " + code_length + ")\n" +
                           Utility.codeToString(code, constant_pool, 0, -1, verbose));

    if(exception_table_length > 0) {
      buf.append("\nException handler(s) = \n" + "From\tTo\tHandler\tType\n");

      for(int i=0; i < exception_table_length; i++)
        buf.append(exception_table[i].toString(constant_pool, verbose) + "\n");
    }

    if(attributes_count > 0) {
      buf.append("\nAttribute(s) = \n");

      for(int i=0; i < attributes_count; i++)
        buf.append(attributes[i].toString() + "\n");
    }

    return buf.toString();
  }

  
Returns:String representation of code chunk.
/**
   * @return String representation of code chunk.
   */
  public final String toString() {
    return toString(true);
  }

  
Returns:deep copy of this attribute
/**
   * @return deep copy of this attribute
   */
  public Attribute copy(ConstantPool constant_pool) {
    Code c = (Code)clone();
    c.code          = (byte[])code.clone();
    c.constant_pool = constant_pool;

    c.exception_table = new CodeException[exception_table_length];
    for(int i=0; i < exception_table_length; i++)
      c.exception_table[i] = exception_table[i].copy();

    c.attributes = new Attribute[attributes_count];
    for(int i=0; i < attributes_count; i++)
      c.attributes[i] = attributes[i].copy(constant_pool);

    return c;
  }
}