| Methods Summary |
|---|
| public void | clear()Clears the stack.
stack = new ArrayList();
|
| protected java.lang.Object | clone()Returns a deep copy of this object; that means, the clone operates
on a new stack. However, the Type objects on the stack are
shared.
OperandStack newstack = new OperandStack(this.maxStack);
newstack.stack = (ArrayList) this.stack.clone();
return newstack;
|
| public boolean | equals(java.lang.Object o)Returns true if and only if this OperandStack
equals another, meaning equal lengths and equal
objects on the stacks.
if (!(o instanceof OperandStack)) return false;
OperandStack s = (OperandStack) o;
return this.stack.equals(s.stack);
|
| public com.sun.org.apache.bcel.internal.verifier.structurals.OperandStack | getClone()Returns a (typed!) clone of this.
return (OperandStack) this.clone();
|
| public void | initializeObject(UninitializedObjectType u)Replaces all occurences of u in this OperandStack instance
with an "initialized" ObjectType.
for (int i=0; i<stack.size(); i++){
if (stack.get(i) == u){
stack.set(i, u.getInitialized());
}
}
|
| public boolean | isEmpty()Returns true IFF this OperandStack is empty.
return stack.isEmpty();
|
| public int | maxStack()Returns the number of stack slots this stack can hold.
return this.maxStack;
|
| public void | merge(com.sun.org.apache.bcel.internal.verifier.structurals.OperandStack s)Merges another stack state into this instance's stack state.
See the Java Virtual Machine Specification, Second Edition, page 146: 4.9.2
for details.
if ( (slotsUsed() != s.slotsUsed()) || (size() != s.size()) )
throw new StructuralCodeConstraintException("Cannot merge stacks of different size:\nOperandStack A:\n"+this+"\nOperandStack B:\n"+s);
for (int i=0; i<size(); i++){
// If the object _was_ initialized and we're supposed to merge
// in some uninitialized object, we reject the code (see vmspec2, 4.9.4, last paragraph).
if ( (! (stack.get(i) instanceof UninitializedObjectType)) && (s.stack.get(i) instanceof UninitializedObjectType) ){
throw new StructuralCodeConstraintException("Backwards branch with an uninitialized object on the stack detected.");
}
// Even harder, we're not initialized but are supposed to broaden
// the known object type
if ( (!(stack.get(i).equals(s.stack.get(i)))) && (stack.get(i) instanceof UninitializedObjectType) && (!(s.stack.get(i) instanceof UninitializedObjectType))){
throw new StructuralCodeConstraintException("Backwards branch with an uninitialized object on the stack detected.");
}
// on the other hand...
if (stack.get(i) instanceof UninitializedObjectType){ //if we have an uninitialized object here
if (! (s.stack.get(i) instanceof UninitializedObjectType)){ //that has been initialized by now
stack.set(i, ((UninitializedObjectType) (stack.get(i))).getInitialized() ); //note that.
}
}
if (! stack.get(i).equals(s.stack.get(i))){
if ( (stack.get(i) instanceof ReferenceType) &&
(s.stack.get(i) instanceof ReferenceType) ){
stack.set(i, ((ReferenceType) stack.get(i)).firstCommonSuperclass((ReferenceType) (s.stack.get(i))));
}
else{
throw new StructuralCodeConstraintException("Cannot merge stacks of different types:\nStack A:\n"+this+"\nStack B:\n"+s);
}
}
}
|
| public com.sun.org.apache.bcel.internal.generic.Type | peek(int i)Returns the element that's i elements below the top element; that means,
iff i==0 the top element is returned. The element is not popped off the stack!
return (Type) stack.get(size()-i-1);
|
| public com.sun.org.apache.bcel.internal.generic.Type | peek()Returns the element on top of the stack. The element is not popped off the stack!
return peek(0);
|
| public com.sun.org.apache.bcel.internal.generic.Type | pop()Returns the element on top of the stack. The element is popped off the stack.
Type e = (Type) stack.remove(size()-1);
return e;
|
| public com.sun.org.apache.bcel.internal.generic.Type | pop(int i)Pops i elements off the stack. ALWAYS RETURNS "null"!!!
for (int j=0; j<i; j++){
pop();
}
return null;
|
| public void | push(com.sun.org.apache.bcel.internal.generic.Type type)Pushes a Type object onto the stack.
if (type == null) throw new AssertionViolatedException("Cannot push NULL onto OperandStack.");
if (type == Type.BOOLEAN || type == Type.CHAR || type == Type.BYTE || type == Type.SHORT){
throw new AssertionViolatedException("The OperandStack does not know about '"+type+"'; use Type.INT instead.");
}
if (slotsUsed() >= maxStack){
throw new AssertionViolatedException("OperandStack too small, should have thrown proper Exception elsewhere. Stack: "+this);
}
stack.add(type);
|
| int | size()Returns the size of this OperandStack; that means, how many Type objects there are.
return stack.size();
|
| public int | slotsUsed()Returns the number of stack slots used.
/* XXX change this to a better implementation using a variable
that keeps track of the actual slotsUsed()-value monitoring
all push()es and pop()s.
*/
int slots = 0;
for (int i=0; i<stack.size(); i++){
slots += peek(i).getSize();
}
return slots;
|
| public java.lang.String | toString()Returns a String representation of this OperandStack instance.
String s = "Slots used: "+slotsUsed()+" MaxStack: "+maxStack+".\n";
for (int i=0; i<size(); i++){
s+=peek(i)+" (Size: "+peek(i).getSize()+")\n";
}
return s;
|
