/*
* Copyright 2003-2007 the original author or authors.
*
* Licensed 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 org.codehaus.groovy.classgen;
import groovyjarjarasm.asm.Label;
import groovyjarjarasm.asm.MethodVisitor;
import groovyjarjarasm.asm.Opcodes;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import org.codehaus.groovy.GroovyBugError;
import org.codehaus.groovy.ast.ClassHelper;
import org.codehaus.groovy.ast.ClassNode;
import org.codehaus.groovy.ast.Parameter;
import org.codehaus.groovy.ast.VariableScope;
/**
* This class is a helper for AsmClassGenerator. It manages
* different aspects of the code of a code block like
* handling labels, defining variables, and scopes.
* After a MethodNode is visited clear should be called, for
* initialization the method init should be used.
* <p>
* Some Notes:
* <ul>
* <li> every push method will require a later pop call
* <li> method parameters may define a category 2 variable, so
* don't ignore the type stored in the variable object
* <li> the index of the variable may not be as assumed when
* the variable is a parameter of a method because the
* parameter may be used in a closure, so don't ignore
* the stored variable index
* <li> the names of temporary variables can be ignored. The names
* are only used for debugging and do not conflict with each
* other or normal variables. For accessing, the index of the
* variable must be used.
* <li> never mix temporary and normal variables by changes to this class.
* While the name is very important for a normal variable, it is only a
* helper construct for temporary variables. That means for example a
* name for a temporary variable can be used multiple times without
* conflict. So mixing them both may lead to the problem that a normal
* or temporary variable is hidden or even removed. That must not happen!
* </ul>
*
*
* @see org.codehaus.groovy.classgen.AsmClassGenerator
* @author Jochen Theodorou
*/
public class CompileStack implements Opcodes {
/**
* @todo remove optimization of this.foo -> this.@foo
*
*/
// state flag
private boolean clear=true;
// current scope
private VariableScope scope;
// current label for continue
private Label continueLabel;
// current label for break
private Label breakLabel;
// available variables on stack
private Map stackVariables = new HashMap();
// index of the last variable on stack
private int currentVariableIndex = 1;
// index for the next variable on stack
private int nextVariableIndex = 1;
// currently temporary variables in use
private final LinkedList temporaryVariables = new LinkedList();
// overall used variables for a method/constructor
private final LinkedList usedVariables = new LinkedList();
// map containing named labels of parenting blocks
private Map superBlockNamedLabels = new HashMap();
// map containing named labels of current block
private Map currentBlockNamedLabels = new HashMap();
// list containing finally blocks
// such a block is created by synchronized or finally and
// must be called for break/continue/return
private LinkedList<BlockRecorder> finallyBlocks = new LinkedList<BlockRecorder>();
private LinkedList<BlockRecorder> visitedBlocks = new LinkedList<BlockRecorder>();
private Label thisStartLabel, thisEndLabel;
private MethodVisitor mv;
private BytecodeHelper helper;
// helper to handle different stack based variables
private final LinkedList stateStack = new LinkedList();
// defines the first variable index useable after
// all parameters of a method
private int localVariableOffset;
// this is used to store the goals for a "break foo" call
// in a loop where foo is a label.
private final Map namedLoopBreakLabel = new HashMap();
//this is used to store the goals for a "continue foo" call
// in a loop where foo is a label.
private final Map namedLoopContinueLabel = new HashMap();
private String className;
private LinkedList<ExceptionTableEntry> typedExceptions = new LinkedList<ExceptionTableEntry>();
private LinkedList<ExceptionTableEntry> untypedExceptions = new LinkedList<ExceptionTableEntry>();
protected static class LabelRange {
public Label start;
public Label end;
}
protected static class BlockRecorder {
private boolean isEmpty = true;
public Runnable excludedStatement;
public LinkedList<LabelRange> ranges;
public BlockRecorder() {
ranges = new LinkedList<LabelRange>();
}
public BlockRecorder(Runnable excludedStatement) {
this();
this.excludedStatement = excludedStatement;
}
public void startRange(Label start) {
LabelRange range = new LabelRange();
range.start = start;
ranges.add(range);
isEmpty = false;
}
public void closeRange(Label end) {
ranges.getLast().end = end;
}
}
private class ExceptionTableEntry {
Label start,end,goal;
String sig;
}
private class StateStackElement {
final VariableScope scope;
final Label continueLabel;
final Label breakLabel;
final int lastVariableIndex;
final int nextVariableIndex;
final Map stackVariables;
final Map currentBlockNamedLabels;
final LinkedList<BlockRecorder> finallyBlocks;
StateStackElement() {
scope = CompileStack.this.scope;
continueLabel = CompileStack.this.continueLabel;
breakLabel = CompileStack.this.breakLabel;
lastVariableIndex = CompileStack.this.currentVariableIndex;
stackVariables = CompileStack.this.stackVariables;
nextVariableIndex = CompileStack.this.nextVariableIndex;
currentBlockNamedLabels = CompileStack.this.currentBlockNamedLabels;
finallyBlocks = CompileStack.this.finallyBlocks;
}
}
protected void pushState() {
stateStack.add(new StateStackElement());
stackVariables = new HashMap(stackVariables);
finallyBlocks = new LinkedList(finallyBlocks);
}
private void popState() {
if (stateStack.size()==0) {
throw new GroovyBugError("Tried to do a pop on the compile stack without push.");
}
StateStackElement element = (StateStackElement) stateStack.removeLast();
scope = element.scope;
continueLabel = element.continueLabel;
breakLabel = element.breakLabel;
currentVariableIndex = element.lastVariableIndex;
stackVariables = element.stackVariables;
nextVariableIndex = element.nextVariableIndex;
finallyBlocks = element.finallyBlocks;
}
public Label getContinueLabel() {
return continueLabel;
}
public Label getBreakLabel() {
return breakLabel;
}
public void removeVar(int tempIndex) {
final Variable head = (Variable) temporaryVariables.removeFirst();
if (head.getIndex() != tempIndex)
throw new GroovyBugError("CompileStack#removeVar: tried to remove a temporary variable in wrong order");
currentVariableIndex = head.getPrevIndex ();
nextVariableIndex = tempIndex;
}
private void setEndLabels(){
Label endLabel = new Label();
mv.visitLabel(endLabel);
for (Iterator iter = stackVariables.values().iterator(); iter.hasNext();) {
Variable var = (Variable) iter.next();
var.setEndLabel(endLabel);
}
thisEndLabel = endLabel;
}
public void pop() {
setEndLabels();
popState();
}
public VariableScope getScope() {
return scope;
}
/**
* creates a temporary variable.
*
* @param var defines type and name
* @param store defines if the toplevel argument of the stack should be stored
* @return the index used for this temporary variable
*/
public int defineTemporaryVariable(org.codehaus.groovy.ast.Variable var, boolean store) {
return defineTemporaryVariable(var.getName(), var.getType(),store);
}
public Variable getVariable(String variableName ) {
return getVariable(variableName,true);
}
/**
* Returns a normal variable.
* <p/>
* If <code>mustExist</code> is true and the normal variable doesn't exist,
* then this method will throw a GroovyBugError. It is not the intention of
* this method to let this happen! And the exception should not be used for
* flow control - it is just acting as an assertion. If the exception is thrown
* then it indicates a bug in the class using CompileStack.
* This method can also not be used to return a temporary variable.
* Temporary variables are not normal variables.
*
* @param variableName name of the variable
* @param mustExist throw exception if variable does not exist
* @return the normal variable or null if not found (and <code>mustExist</code> not true)
*/
public Variable getVariable(String variableName, boolean mustExist) {
if (variableName.equals("this")) return Variable.THIS_VARIABLE;
if (variableName.equals("super")) return Variable.SUPER_VARIABLE;
Variable v = (Variable) stackVariables.get(variableName);
if (v == null && mustExist)
throw new GroovyBugError("tried to get a variable with the name " + variableName + " as stack variable, but a variable with this name was not created");
return v;
}
/**
* creates a temporary variable.
*
* @param name defines type and name
* @param store defines if the toplevel argument of the stack should be stored
* @return the index used for this temporary variable
*/
public int defineTemporaryVariable(String name,boolean store) {
return defineTemporaryVariable(name, ClassHelper.DYNAMIC_TYPE,store);
}
/**
* creates a temporary variable.
*
* @param name defines the name
* @param node defines the node
* @param store defines if the toplevel argument of the stack should be stored
* @return the index used for this temporary variable
*/
public int defineTemporaryVariable(String name, ClassNode node, boolean store) {
Variable answer = defineVar(name,node,false);
temporaryVariables.addFirst(answer); // TRICK: we add at the beginning so when we find for remove or get we always have the last one
usedVariables.removeLast();
if (store) mv.visitVarInsn(ASTORE, currentVariableIndex);
return answer.getIndex();
}
private void resetVariableIndex(boolean isStatic) {
if (!isStatic) {
currentVariableIndex=1;
nextVariableIndex=1;
} else {
currentVariableIndex=0;
nextVariableIndex=0;
}
}
/**
* Clears the state of the class. This method should be called
* after a MethodNode is visited. Note that a call to init will
* fail if clear is not called before
*/
public void clear() {
if (stateStack.size()>1) {
int size = stateStack.size()-1;
throw new GroovyBugError("the compile stack contains "+size+" more push instruction"+(size==1?"":"s")+" than pops.");
}
clear = true;
// br experiment with local var table so debuggers can retrieve variable names
if (true) {//AsmClassGenerator.CREATE_DEBUG_INFO) {
if (thisEndLabel==null) setEndLabels();
if (!scope.isInStaticContext()) {
// write "this"
mv.visitLocalVariable("this", className, null, thisStartLabel, thisEndLabel, 0);
}
for (Iterator iterator = usedVariables.iterator(); iterator.hasNext();) {
Variable v = (Variable) iterator.next();
String type = BytecodeHelper.getTypeDescription(v.getType());
Label start = v.getStartLabel();
Label end = v.getEndLabel();
// GRECLIPSE: start: guard for bad code
if (start!=null && end!=null)
mv.visitLocalVariable(v.getName(), type, null, start, end, v.getIndex());
}
}
//exception table writing
for (ExceptionTableEntry ep : typedExceptions) {
mv.visitTryCatchBlock(ep.start, ep.end, ep.goal, ep.sig);
}
//exception table writing
for (ExceptionTableEntry ep : untypedExceptions) {
mv.visitTryCatchBlock(ep.start, ep.end, ep.goal, ep.sig);
}
pop();
typedExceptions.clear();
untypedExceptions.clear();
stackVariables.clear();
usedVariables.clear();
scope = null;
finallyBlocks.clear();
mv=null;
resetVariableIndex(false);
superBlockNamedLabels.clear();
currentBlockNamedLabels.clear();
namedLoopBreakLabel.clear();
namedLoopContinueLabel.clear();
continueLabel=null;
breakLabel=null;
helper = null;
thisStartLabel=null;
thisEndLabel=null;
}
public void addExceptionBlock (Label start, Label end, Label goal,
String sig)
{
// this code is in an extra method to avoid
// lazy initialization issues
ExceptionTableEntry ep = new ExceptionTableEntry();
ep.start = start;
ep.end = end;
ep.sig = sig;
ep.goal = goal;
if (sig==null) {
untypedExceptions.add(ep);
} else {
typedExceptions.add(ep);
}
}
/**
* initializes this class for a MethodNode. This method will
* automatically define variables for the method parameters
* and will create references if needed. The created variables
* can be accessed by calling getVariable().
*
*/
protected void init(VariableScope el, Parameter[] parameters, MethodVisitor mv, ClassNode cn) {
if (!clear) throw new GroovyBugError("CompileStack#init called without calling clear before");
clear=false;
pushVariableScope(el);
this.mv = mv;
this.helper = new BytecodeHelper(mv);
defineMethodVariables(parameters,el.isInStaticContext());
this.className = BytecodeHelper.getTypeDescription(cn);
}
/**
* Causes the statestack to add an element and sets
* the given scope as new current variable scope. Creates
* a element for the state stack so pop has to be called later
*/
protected void pushVariableScope(VariableScope el) {
pushState();
scope = el;
superBlockNamedLabels = new HashMap(superBlockNamedLabels);
superBlockNamedLabels.putAll(currentBlockNamedLabels);
currentBlockNamedLabels = new HashMap();
}
/**
* Should be called when decending into a loop that defines
* also a scope. Calls pushVariableScope and prepares labels
* for a loop structure. Creates a element for the state stack
* so pop has to be called later
*/
protected void pushLoop(VariableScope el, String labelName) {
pushVariableScope(el);
initLoopLabels(labelName);
}
private void initLoopLabels(String labelName) {
continueLabel = new Label();
breakLabel = new Label();
if (labelName!=null) {
namedLoopBreakLabel.put(labelName,breakLabel);
namedLoopContinueLabel.put(labelName,continueLabel);
}
}
/**
* Should be called when decending into a loop that does
* not define a scope. Creates a element for the state stack
* so pop has to be called later
*/
protected void pushLoop(String labelName) {
pushState();
initLoopLabels(labelName);
}
/**
* Used for <code>break foo</code> inside a loop to end the
* execution of the marked loop. This method will return the
* break label of the loop if there is one found for the name.
* If not, the current break label is returned.
*/
protected Label getNamedBreakLabel(String name) {
Label label = getBreakLabel();
Label endLabel = null;
if (name!=null) endLabel = (Label) namedLoopBreakLabel.get(name);
if (endLabel!=null) label = endLabel;
return label;
}
/**
* Used for <code>continue foo</code> inside a loop to continue
* the execution of the marked loop. This method will return
* the break label of the loop if there is one found for the
* name. If not, getLabel is used.
*/
protected Label getNamedContinueLabel(String name) {
Label label = getLabel(name);
Label endLabel = null;
if (name!=null) endLabel = (Label) namedLoopContinueLabel.get(name);
if (endLabel!=null) label = endLabel;
return label;
}
/**
* Creates a new break label and a element for the state stack
* so pop has to be called later
*/
protected Label pushSwitch(){
pushState();
breakLabel = new Label();
return breakLabel;
}
/**
* because a boolean Expression may not be evaluated completly
* it is important to keep the registers clean
*/
protected void pushBooleanExpression(){
pushState();
}
private Variable defineVar(String name, ClassNode type, boolean methodParameterUsedInClosure) {
int prevCurrent = currentVariableIndex;
makeNextVariableID(type);
int index = currentVariableIndex;
if (methodParameterUsedInClosure) {
index = localVariableOffset++;
type = ClassHelper.getWrapper(type);
}
Variable answer = new Variable(index, type, name, prevCurrent);
usedVariables.add(answer);
answer.setHolder(methodParameterUsedInClosure);
return answer;
}
private void makeLocalVariablesOffset(Parameter[] paras,boolean isInStaticContext) {
resetVariableIndex(isInStaticContext);
for (int i = 0; i < paras.length; i++) {
makeNextVariableID(paras[i].getType());
}
localVariableOffset = nextVariableIndex;
resetVariableIndex(isInStaticContext);
}
private void defineMethodVariables(Parameter[] paras,boolean isInStaticContext) {
Label startLabel = new Label();
thisStartLabel = startLabel;
mv.visitLabel(startLabel);
makeLocalVariablesOffset(paras,isInStaticContext);
boolean hasHolder = false;
for (int i = 0; i < paras.length; i++) {
String name = paras[i].getName();
Variable answer;
ClassNode type = paras[i].getType();
if (paras[i].isClosureSharedVariable()) {
answer = defineVar(name, type, true);
helper.load(type,currentVariableIndex);
helper.box(type);
// GROOVY-4237, the original variable should always appear
// in the variable index, otherwise some programs get into
// trouble. So we define a dummy variable for the packaging
// phase and let it end right away before the normal
// reference will be used
Label newStart = new Label();
mv.visitLabel(newStart);
Variable var = new Variable(currentVariableIndex, paras[i].getOriginType(), name, currentVariableIndex);
var.setStartLabel(startLabel);
var.setEndLabel(newStart);
usedVariables.add(var);
answer.setStartLabel(newStart);
createReference(answer);
hasHolder = true;
} else {
answer = defineVar(name,type,false);
answer.setStartLabel(startLabel);
}
stackVariables.put(name, answer);
}
if (hasHolder) {
nextVariableIndex = localVariableOffset;
}
}
private void createReference(Variable reference) {
mv.visitTypeInsn(NEW, "groovy/lang/Reference");
mv.visitInsn(DUP_X1);
mv.visitInsn(SWAP);
mv.visitMethodInsn(INVOKESPECIAL, "groovy/lang/Reference", "<init>", "(Ljava/lang/Object;)V");
mv.visitVarInsn(ASTORE, reference.getIndex());
}
/**
* Defines a new Variable using an AST variable.
* @param initFromStack if true the last element of the
* stack will be used to initilize
* the new variable. If false null
* will be used.
*/
public Variable defineVariable(org.codehaus.groovy.ast.Variable v, boolean initFromStack) {
String name = v.getName();
Variable answer = defineVar(name,v.getType(),false);
if (v.isClosureSharedVariable()) answer.setHolder(true);
stackVariables.put(name, answer);
Label startLabel = new Label();
answer.setStartLabel(startLabel);
if (answer.isHolder()) {
if (!initFromStack) mv.visitInsn(ACONST_NULL);
createReference(answer);
} else {
if (!initFromStack) mv.visitInsn(ACONST_NULL);
mv.visitVarInsn(ASTORE, currentVariableIndex);
}
mv.visitLabel(startLabel);
return answer;
}
/**
* @param name the name of the variable of interest
* @return true if a variable is already defined
*/
public boolean containsVariable(String name) {
return stackVariables.containsKey(name);
}
/**
* Calculates the index of the next free register stores it
* and sets the current variable index to the old value
*/
private void makeNextVariableID(ClassNode type) {
currentVariableIndex = nextVariableIndex;
if (type==ClassHelper.long_TYPE || type==ClassHelper.double_TYPE) {
nextVariableIndex++;
}
nextVariableIndex++;
}
/**
* Returns the label for the given name
*/
public Label getLabel(String name) {
if (name==null) return null;
Label l = (Label) superBlockNamedLabels.get(name);
if (l==null) l = createLocalLabel(name);
return l;
}
/**
* creates a new named label
*/
public Label createLocalLabel(String name) {
Label l = (Label) currentBlockNamedLabels.get(name);
if (l==null) {
l = new Label();
currentBlockNamedLabels.put(name,l);
}
return l;
}
public void applyFinallyBlocks(Label label, boolean isBreakLabel) {
// first find the state defining the label. That is the state
// directly after the state not knowing this label. If no state
// in the list knows that label, then the defining state is the
// current state.
StateStackElement result = null;
for (ListIterator iter = stateStack.listIterator(stateStack.size()); iter.hasPrevious();) {
StateStackElement element = (StateStackElement) iter.previous();
if (!element.currentBlockNamedLabels.values().contains(label)) {
if (isBreakLabel && element.breakLabel != label) {
result = element;
break;
}
if (!isBreakLabel && element.continueLabel != label) {
result = element;
break;
}
}
}
List<BlockRecorder> blocksToRemove;
if (result==null) {
// all Blocks do know the label, so use all finally blocks
blocksToRemove = (List<BlockRecorder>) Collections.EMPTY_LIST;
} else {
blocksToRemove = result.finallyBlocks;
}
List<BlockRecorder> blocks = new LinkedList<BlockRecorder>(finallyBlocks);
blocks.removeAll(blocksToRemove);
applyBlockRecorder(blocks);
}
private void applyBlockRecorder(List<BlockRecorder> blocks) {
if (blocks.size()==0 || blocks.size()==visitedBlocks.size()) return;
Label end = new Label();
mv.visitInsn(NOP);
mv.visitLabel(end);
Label newStart = new Label();
for (BlockRecorder fb : blocks) {
if (visitedBlocks.contains(fb)) continue;
fb.closeRange(end);
// we exclude the finally block from the exception table
// here to avoid double visiting of finally statements
fb.excludedStatement.run();
fb.startRange(newStart);
}
mv.visitInsn(NOP);
mv.visitLabel(newStart);
}
public void applyBlockRecorder() {
applyBlockRecorder(finallyBlocks);
}
public boolean hasBlockRecorder() {
return !finallyBlocks.isEmpty();
}
public void pushBlockRecorder(BlockRecorder recorder) {
pushState();
finallyBlocks.addFirst(recorder);
}
public void pushBlockRecorderVisit(BlockRecorder finallyBlock) {
visitedBlocks.add(finallyBlock);
}
public void popBlockRecorderVisit(BlockRecorder finallyBlock) {
visitedBlocks.remove(finallyBlock);
}
public void writeExceptionTable(BlockRecorder block, Label goal, String sig) {
if (block.isEmpty) return;
for (LabelRange range : block.ranges) {
mv.visitTryCatchBlock(range.start, range.end, goal, sig);
}
}
}