serp.bytecode.TableSwitchInstruction Maven / Gradle / Ivy
package serp.bytecode;
import java.io.*;
import java.util.*;
import serp.bytecode.visitor.*;
/**
* The tableswitch instruction.
*
* @author Abe White
*/
public class TableSwitchInstruction extends JumpInstruction {
// case info
private int _low = 0;
private int _high = 0;
private List _cases = new LinkedList();
TableSwitchInstruction(Code owner) {
super(owner, Constants.TABLESWITCH);
}
/**
* Returns the current byte offsets for the different
* switch cases in this Instruction.
*/
public int[] getOffsets() {
int bi = getByteIndex();
int[] offsets = new int[_cases.size()];
for (int i = 0; i < _cases.size(); i++)
offsets[i] = ((InstructionPtrStrategy) _cases.get(i)).getByteIndex()
- bi;
return offsets;
}
/**
* Sets the offsets for the instructions representing the different
* switch statement cases. WARNING: these offsets will not be changed
* in the event that the code is modified following this call. It is
* typically a good idea to follow this call with a call to updateTargets
* as soon as the instructions at the given offsets are valid, at which
* point the Instructions themselves will be used as the targets and the
* offsets will be updated as expected.
*/
public void setOffsets(int[] offsets) {
int bi = getByteIndex();
_cases.clear();
for (int i = 0; i < offsets.length; i++) {
InstructionPtrStrategy next = new InstructionPtrStrategy(this);
next.setByteIndex(offsets[i] + bi);
_cases.add(next);
}
invalidateByteIndexes();
}
int getLength() {
// don't call super
int length = 1;
// make the first byte of the 'default' a multiple of 4 from the
// start of the method
int byteIndex = getByteIndex() + 1;
for (; (byteIndex % 4) != 0; byteIndex++, length++);
// default, low, high
length += 12;
// offsets
length += (4 * _cases.size());
return length;
}
/**
* Synonymous with {@link #getTarget}.
*/
public Instruction getDefaultTarget() {
return getTarget();
}
/**
* Synonymous with {@link #setTarget}.
*/
public TableSwitchInstruction setDefaultTarget(Instruction ins) {
return (TableSwitchInstruction) setTarget(ins);
}
/**
* Synonymous with {@link #getOffset}.
*/
public int getDefaultOffset() {
return getOffset();
}
/**
* Synonymous with {@link #setOffset}.
*/
public TableSwitchInstruction setDefaultOffset(int offset) {
setOffset(offset);
return this;
}
public int getLow() {
return _low;
}
public TableSwitchInstruction setLow(int low) {
_low = low;
return this;
}
public int getHigh() {
return _high;
}
public TableSwitchInstruction setHigh(int high) {
_high = high;
return this;
}
/**
* Return the targets for this switch, or empty array if not set.
*/
public Instruction[] getTargets() {
Instruction[] result = new Instruction[_cases.size()];
for (int i = 0; i < _cases.size(); i++)
result[i] = ((InstructionPtrStrategy) _cases.get(i)).
getTargetInstruction();
return result;
}
/**
* Set the jump points for this switch.
*
* @return this instruction, for method chaining
*/
public TableSwitchInstruction setTargets(Instruction[] targets) {
_cases.clear();
if (targets != null)
for (int i = 0; i < targets.length; i++)
addTarget(targets[i]);
return this;
}
/**
* Add a target to this switch.
*
* @return this instruction, for method chaining
*/
public TableSwitchInstruction addTarget(Instruction target) {
_cases.add(new InstructionPtrStrategy(this, target));
invalidateByteIndexes();
return this;
}
public int getStackChange() {
return -1;
}
private Instruction findTarget(int jumpByteIndex, List inss) {
Instruction ins;
for (Iterator itr = inss.iterator(); itr.hasNext();) {
ins = (Instruction) itr.next();
if (ins.getByteIndex() == jumpByteIndex)
return ins;
}
return null;
}
public void updateTargets() {
super.updateTargets();
for (Iterator itr = _cases.iterator(); itr.hasNext();)
((InstructionPtrStrategy) itr.next()).updateTargets();
}
public void replaceTarget(Instruction oldTarget, Instruction newTarget) {
super.replaceTarget(oldTarget, newTarget);
for (Iterator itr = _cases.iterator(); itr.hasNext();)
((InstructionPtrStrategy) itr.next()).replaceTarget(oldTarget,
newTarget);
}
public void acceptVisit(BCVisitor visit) {
visit.enterTableSwitchInstruction(this);
visit.exitTableSwitchInstruction(this);
}
void read(Instruction orig) {
super.read(orig);
TableSwitchInstruction ins = (TableSwitchInstruction) orig;
setLow(ins.getLow());
setHigh(ins.getHigh());
InstructionPtrStrategy incoming;
for (Iterator itr = ins._cases.iterator(); itr.hasNext();) {
incoming = (InstructionPtrStrategy) itr.next();
InstructionPtrStrategy next = new InstructionPtrStrategy(this);
next.setByteIndex(incoming.getByteIndex());
_cases.add(next);
}
invalidateByteIndexes();
}
void read(DataInput in) throws IOException {
// don't call super
int bi = getByteIndex();
for (int byteIndex = bi + 1; (byteIndex % 4) != 0; byteIndex++)
in.readByte();
setOffset(in.readInt());
setLow(in.readInt());
setHigh(in.readInt());
_cases.clear();
for (int i = 0; i < (_high - _low + 1); i++) {
InstructionPtrStrategy next = new InstructionPtrStrategy(this);
next.setByteIndex(bi + in.readInt());
_cases.add(next);
}
}
void write(DataOutput out) throws IOException {
// don't call super
int bi = getByteIndex();
for (int byteIndex = bi + 1; (byteIndex % 4) != 0; byteIndex++)
out.writeByte(0);
out.writeInt(getOffset());
out.writeInt(getLow());
out.writeInt(getHigh());
for (Iterator itr = _cases.iterator(); itr.hasNext();)
out.writeInt(((InstructionPtrStrategy) itr.next()).getByteIndex()
- bi);
}
}