com.feilong.lib.javassist.bytecode.analysis.Frame Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of feilong Show documentation
Show all versions of feilong Show documentation
feilong is a suite of core and expanded libraries that include utility classes, http, excel,cvs, io classes, and much much more.
/*
* Javassist, a Java-bytecode translator toolkit.
* Copyright (C) 1999- Shigeru Chiba. All Rights Reserved.
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. Alternatively, the contents of this file may be used under
* the terms of the GNU Lesser General Public License Version 2.1 or later,
* or the Apache License Version 2.0.
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*/
package com.feilong.lib.javassist.bytecode.analysis;
/**
* Represents the stack frame and local variable table at a particular point in time.
*
* @author Jason T. Greene
*/
public class Frame{
private Type[] locals;
private Type[] stack;
private int top;
private boolean jsrMerged;
private boolean retMerged;
/**
* Create a new frame with the specified local variable table size, and max stack size
*
* @param locals
* the number of local variable table entries
* @param stack
* the maximum stack size
*/
public Frame(int locals, int stack){
this.locals = new Type[locals];
this.stack = new Type[stack];
}
/**
* Returns the local varaible table entry at index.
*
* @param index
* the position in the table
* @return the type if one exists, or null if the position is empty
*/
public Type getLocal(int index){
return locals[index];
}
/**
* Sets the local variable table entry at index to a type.
*
* @param index
* the position in the table
* @param type
* the type to set at the position
*/
public void setLocal(int index,Type type){
locals[index] = type;
}
/**
* Returns the type on the stack at the specified index.
*
* @param index
* the position on the stack
* @return the type of the stack position
*/
public Type getStack(int index){
return stack[index];
}
/**
* Sets the type of the stack position
*
* @param index
* the position on the stack
* @param type
* the type to set
*/
public void setStack(int index,Type type){
stack[index] = type;
}
/**
* Empties the stack
*/
public void clearStack(){
top = 0;
}
/**
* Gets the index of the type sitting at the top of the stack.
* This is not to be confused with a length operation which
* would return the number of elements, not the position of
* the last element.
*
* @return the position of the element at the top of the stack
*/
public int getTopIndex(){
return top - 1;
}
/**
* Returns the number of local variable table entries, specified
* at construction.
*
* @return the number of local variable table entries
*/
public int localsLength(){
return locals.length;
}
/**
* Gets the top of the stack without altering it
*
* @return the top of the stack
*/
public Type peek(){
if (top < 1){
throw new IndexOutOfBoundsException("Stack is empty");
}
return stack[top - 1];
}
/**
* Alters the stack to contain one less element and return it.
*
* @return the element popped from the stack
*/
public Type pop(){
if (top < 1){
throw new IndexOutOfBoundsException("Stack is empty");
}
return stack[--top];
}
/**
* Alters the stack by placing the passed type on the top
*
* @param type
* the type to add to the top
*/
public void push(Type type){
stack[top++] = type;
}
/**
* Makes a shallow copy of this frame, i.e. the type instances will
* remain the same.
*
* @return the shallow copy
*/
public Frame copy(){
Frame frame = new Frame(locals.length, stack.length);
System.arraycopy(locals, 0, frame.locals, 0, locals.length);
System.arraycopy(stack, 0, frame.stack, 0, stack.length);
frame.top = top;
return frame;
}
/**
* Makes a shallow copy of the stack portion of this frame. The local
* variable table size will be copied, but its contents will be empty.
*
* @return the shallow copy of the stack
*/
public Frame copyStack(){
Frame frame = new Frame(locals.length, stack.length);
System.arraycopy(stack, 0, frame.stack, 0, stack.length);
frame.top = top;
return frame;
}
/**
* Merges all types on the stack of this frame instance with that of the specified frame.
* The local variable table is left untouched.
*
* @param frame
* the frame to merge the stack from
* @return true if any changes where made
*/
public boolean mergeStack(Frame frame){
boolean changed = false;
if (top != frame.top){
throw new RuntimeException("Operand stacks could not be merged, they are different sizes!");
}
for (int i = 0; i < top; i++){
if (stack[i] != null){
Type prev = stack[i];
Type merged = prev.merge(frame.stack[i]);
if (merged == Type.BOGUS){
throw new RuntimeException("Operand stacks could not be merged due to differing primitive types: pos = " + i);
}
stack[i] = merged;
// always replace the instance in case a multi-interface type changes to a normal Type
if ((!merged.equals(prev)) || merged.popChanged()){
changed = true;
}
}
}
return changed;
}
/**
* Merges all types on the stack and local variable table of this frame with that of the specified
* type.
*
* @param frame
* the frame to merge with
* @return true if any changes to this frame where made by this merge
*/
public boolean merge(Frame frame){
boolean changed = false;
// Local variable table
for (int i = 0; i < locals.length; i++){
if (locals[i] != null){
Type prev = locals[i];
Type merged = prev.merge(frame.locals[i]);
// always replace the instance in case a multi-interface type changes to a normal Type
locals[i] = merged;
if (!merged.equals(prev) || merged.popChanged()){
changed = true;
}
}else if (frame.locals[i] != null){
locals[i] = frame.locals[i];
changed = true;
}
}
changed |= mergeStack(frame);
return changed;
}
@Override
public String toString(){
StringBuffer buffer = new StringBuffer();
buffer.append("locals = [");
for (int i = 0; i < locals.length; i++){
buffer.append(locals[i] == null ? "empty" : locals[i].toString());
if (i < locals.length - 1){
buffer.append(", ");
}
}
buffer.append("] stack = [");
for (int i = 0; i < top; i++){
buffer.append(stack[i]);
if (i < top - 1){
buffer.append(", ");
}
}
buffer.append("]");
return buffer.toString();
}
/**
* Whether or not state from the source JSR instruction has been merged
*
* @return true if JSR state has been merged
*/
boolean isJsrMerged(){
return jsrMerged;
}
/**
* Sets whether of not the state from the source JSR instruction has been merged
*
* @param jsrMerged
* true if merged, otherwise false
*/
void setJsrMerged(boolean jsrMerged){
this.jsrMerged = jsrMerged;
}
/**
* Whether or not state from the RET instruction, of the subroutine that was jumped
* to has been merged.
*
* @return true if RET state has been merged
*/
boolean isRetMerged(){
return retMerged;
}
/**
* Sets whether or not state from the RET instruction, of the subroutine that was jumped
* to has been merged.
*
* @param retMerged
* true if RET state has been merged
*/
void setRetMerged(boolean retMerged){
this.retMerged = retMerged;
}
}