org.fife.rsta.ac.java.classreader.ExceptionTableEntry Maven / Gradle / Ivy
/*
* 03/21/2010
*
* Copyright (C) 2010 Robert Futrell
* robert_futrell at users.sourceforge.net
* http://fifesoft.com/rsyntaxtextarea
*
* This library is distributed under a modified BSD license. See the included
* RSTALanguageSupport.License.txt file for details.
*/
package org.fife.rsta.ac.java.classreader;
import org.fife.rsta.ac.java.classreader.attributes.Code;
import org.fife.rsta.ac.java.classreader.constantpool.ConstantClassInfo;
import java.io.*;
/**
* An entry in the exception table of a {@code Code} attribute. This denotes
* either a catch or finally block (the section of code it
* covers, the type of Throwable it handles, and the location of the
* exception handler code).
*
* @author Robert Futrell
* @version 1.0
*/
public class ExceptionTableEntry {
/**
* The parent class file.
*/
private ClassFile cf;
/**
* Start of the range in the code array at which the exception handler is
* active.
*/
private int startPC; // u2
/**
* End of the range in the code array at which the exception handler is
* active. This value must be either a valid index into the code array of
* the opcode of an instruction, or be equal to
* {@link Code#getCodeLength()}.
*/
private int endPC; // u2
/**
* The start of the exception handler. This value must be a valid index
* into the code array and must be the index of the opcode of an
* instruction.
*/
private int handlerPC; // u2
/**
* If the value of {@link #catchType} is nonzero, it must be a valid
* index into the constant pool. The constant pool entry at that index
* must be a {@link ConstantClassInfo} structure representing a class of
* exceptions that this exception handler is designated to catch. This
* class must be the class Throwable or one of its subclasses.
* The exception handler will be called only if the thrown exception is
* an instance of the given class or one of its subclasses.
*
* If the value of {@link #catchType} is zero, this exception handler is
* for all exceptions. This is used to implement finally.
*/
private int catchType; // u2
/**
* Constructor.
*
* @param cf The parent class file.
*/
public ExceptionTableEntry(ClassFile cf) {
this.cf = cf;
}
/**
* Returns the name of the Throwable type caught and handled
* by this exception handler.
*
* @param fullyQualified Whether the name should be fully qualified.
* @return The name of the Throwable type, or null
* if this entry denotes a finally block.
*/
public String getCaughtThrowableType(boolean fullyQualified) {
return catchType==0 ? null :
cf.getClassNameFromConstantPool(catchType, fullyQualified);
}
public int getEndPC() {
return endPC;
}
public int getHandlerPC() {
return handlerPC;
}
public int getStartPC() {
return startPC;
}
/**
* Reads an exception table entry from an input stream.
*
* @param cf The class file.
* @param in The input stream to read from.
* @return The exception table entry.
* @throws IOException If an IO error occurs.
*/
public static ExceptionTableEntry read(ClassFile cf, DataInputStream in)
throws IOException {
ExceptionTableEntry entry = new ExceptionTableEntry(cf);
entry.startPC = in.readUnsignedShort();
entry.endPC = in.readUnsignedShort();
entry.handlerPC = in.readUnsignedShort();
entry.catchType = in.readUnsignedShort();
return entry;
}
}