/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
*
* Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.
*
* The contents of this file are subject to the terms of either the GNU
* General Public License Version 2 only ("GPL") or the Common
* Development and Distribution License("CDDL") (collectively, the
* "License"). You may not use this file except in compliance with the
* License. You can obtain a copy of the License at
* http://www.netbeans.org/cddl-gplv2.html
* or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
* specific language governing permissions and limitations under the
* License. When distributing the software, include this License Header
* Notice in each file and include the License file at
* nbbuild/licenses/CDDL-GPL-2-CP. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the GPL Version 2 section of the License file that
* accompanied this code. If applicable, add the following below the
* License Header, with the fields enclosed by brackets [] replaced by
* your own identifying information:
* "Portions Copyrighted [year] [name of copyright owner]"
*
* Contributor(s):
*
* The Original Software is NetBeans. The Initial Developer of the Original
* Software is Sun Microsystems, Inc. Portions Copyright 1997-2007 Sun
* Microsystems, Inc. All Rights Reserved.
*
* If you wish your version of this file to be governed by only the CDDL
* or only the GPL Version 2, indicate your decision by adding
* "[Contributor] elects to include this software in this distribution
* under the [CDDL or GPL Version 2] license." If you do not indicate a
* single choice of license, a recipient has the option to distribute
* your version of this file under either the CDDL, the GPL Version 2 or
* to extend the choice of license to its licensees as provided above.
* However, if you add GPL Version 2 code and therefore, elected the GPL
* Version 2 license, then the option applies only if the new code is
* made subject to such option by the copyright holder.
*/
package org.netbeans.modules.scala.debugger.projects;
import com.sun.source.tree.AnnotationTree;
import com.sun.source.tree.ArrayAccessTree;
import com.sun.source.tree.ArrayTypeTree;
import com.sun.source.tree.AssertTree;
import com.sun.source.tree.AssignmentTree;
import com.sun.source.tree.BinaryTree;
import com.sun.source.tree.BlockTree;
import com.sun.source.tree.BreakTree;
import com.sun.source.tree.CaseTree;
import com.sun.source.tree.CatchTree;
import com.sun.source.tree.ClassTree;
import com.sun.source.tree.CompilationUnitTree;
import com.sun.source.tree.CompoundAssignmentTree;
import com.sun.source.tree.ConditionalExpressionTree;
import com.sun.source.tree.ContinueTree;
import com.sun.source.tree.DoWhileLoopTree;
import com.sun.source.tree.EmptyStatementTree;
import com.sun.source.tree.EnhancedForLoopTree;
import com.sun.source.tree.ErroneousTree;
import com.sun.source.tree.ExpressionStatementTree;
import com.sun.source.tree.ExpressionTree;
import com.sun.source.tree.ForLoopTree;
import com.sun.source.tree.IdentifierTree;
import com.sun.source.tree.IfTree;
import com.sun.source.tree.ImportTree;
import com.sun.source.tree.InstanceOfTree;
import com.sun.source.tree.LabeledStatementTree;
import com.sun.source.tree.LineMap;
import com.sun.source.tree.LiteralTree;
import com.sun.source.tree.MemberSelectTree;
import com.sun.source.tree.MethodInvocationTree;
import com.sun.source.tree.MethodTree;
import com.sun.source.tree.ModifiersTree;
import com.sun.source.tree.NewArrayTree;
import com.sun.source.tree.NewClassTree;
import com.sun.source.tree.ParameterizedTypeTree;
import com.sun.source.tree.ParenthesizedTree;
import com.sun.source.tree.PrimitiveTypeTree;
import com.sun.source.tree.ReturnTree;
import com.sun.source.tree.StatementTree;
import com.sun.source.tree.SwitchTree;
import com.sun.source.tree.SynchronizedTree;
import com.sun.source.tree.ThrowTree;
import com.sun.source.tree.Tree;
import com.sun.source.tree.TreeVisitor;
import com.sun.source.tree.TryTree;
import com.sun.source.tree.TypeCastTree;
import com.sun.source.tree.TypeParameterTree;
import com.sun.source.tree.UnaryTree;
import com.sun.source.tree.VariableTree;
import com.sun.source.tree.WhileLoopTree;
import com.sun.source.tree.WildcardTree;
import com.sun.source.util.SourcePositions;
import com.sun.source.util.TreeScanner;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Stack;
import java.util.TreeSet;
/**
* A tree scanner, which collects expressions on a given line.
*
* @author Martin Entlicher
*/
class ExpressionScanner extends TreeScanner<List<Tree>, ExpressionScanner.ExpressionsInfo> {
private int lineNumber;
private CompilationUnitTree tree;
private SourcePositions positions;
private LineMap lineMap;
private boolean checkBounds = true;
public ExpressionScanner(int lineNumber, CompilationUnitTree tree, SourcePositions positions) {
this.tree = tree;
this.lineNumber = lineNumber;
this.positions = positions;
this.lineMap = tree.getLineMap();
}
private boolean acceptsTree(Tree aTree) {
/*
int start = (int) positions.getStartPosition(tree, aTree);
int end = (int) positions.getEndPosition(tree, aTree);
return start <= offset && offset < end;
*/
if (!checkBounds) return true;
int startLine = (int) lineMap.getLineNumber(positions.getStartPosition(tree, aTree));
if (startLine == lineNumber) {
return true;
} else {
return false;
/*
return startLine < lineNumber &&
lineMap.getLineNumber(positions.getEndPosition(tree, aTree)) >= lineNumber;
*/
}
}
private boolean isCurrentTree(Tree aTree) {
int startLine = (int) lineMap.getLineNumber(positions.getStartPosition(tree, aTree));
int endLine = (int) lineMap.getLineNumber(positions.getEndPosition(tree, aTree));
return startLine <= lineNumber && lineNumber <= endLine;
}
public List<Tree> reduce(List<Tree> r1, List<Tree> r2) {
if (r1 == null || r1.size() == 0) {
return r2;
}
if (r2 == null || r2.size() == 0) {
return r1;
}
r1.addAll(r2);
return r1;
}
public List<Tree> scan(Iterable<? extends Tree> nodes, ExpressionScanner.ExpressionsInfo p) {
List<Tree> r = null;
if (nodes != null) {
boolean first = true;
for (Tree node : nodes) {
r = (first ? scan(node, p) : reduce(r, scan(node, p)));
first = false;
}
}
return r;
}
private List<Tree> scan(Tree t1, Tree t2, ExpressionScanner.ExpressionsInfo p) {
List<Tree> result = scan(t1, p);
result = reduce(result, scan(t2, p));
return result;
}
public List<Tree> visitAnnotation(AnnotationTree node, ExpressionScanner.ExpressionsInfo p) {
return null;
}
public List<Tree> visitMethodInvocation(MethodInvocationTree node, ExpressionScanner.ExpressionsInfo p) {
List<Tree> result = scan(node.getTypeArguments(), p);
result = reduce(result, scan(node.getMethodSelect(), p));
result = reduce(result, scan(node.getArguments(), p));
if (result == null) {
result = new ArrayList();
}
result.add(node);
return result;
}
public List<Tree> visitAssert(AssertTree node, ExpressionScanner.ExpressionsInfo p) {
List<Tree> result = scan(node.getCondition(), p);
result = reduce(result, scan(node.getDetail(), p));
return result;
}
public List<Tree> visitAssignment(AssignmentTree node, ExpressionScanner.ExpressionsInfo p) {
return scan(node.getVariable(), node.getExpression(), p);
}
public List<Tree> visitCompoundAssignment(CompoundAssignmentTree node, ExpressionScanner.ExpressionsInfo p) {
return scan(node.getVariable(), node.getExpression(), p);
}
public List<Tree> visitBinary(BinaryTree node, ExpressionScanner.ExpressionsInfo p) {
return scan(node.getLeftOperand(), node.getRightOperand(), p);
}
//public List<Tree> visitBlock(BlockTree node, ExpressionScanner.ExpressionsInfo p) {
//}
//public List<Tree> visitBreak(BreakTree node, ExpressionScanner.ExpressionsInfo p) {
//}
public List<Tree> visitCase(CaseTree node, ExpressionScanner.ExpressionsInfo p) {
List<Tree> result = scan(node.getExpression(), p);
result = reduce(result, scan(node.getStatements(), p));
return result;
}
//public List<Tree> visitCatch(CatchTree node, ExpressionScanner.ExpressionsInfo p) {
//}
//public List<Tree> visitClass(ClassTree node, ExpressionScanner.ExpressionsInfo p) {
//}
public List<Tree> visitConditionalExpression(ConditionalExpressionTree node, ExpressionScanner.ExpressionsInfo p) {
List<Tree> cond = scan(node.getCondition(), p);
Tree lastCond = null;
if (cond != null) {
lastCond = cond.get(cond.size() - 1);
}
List<Tree> rT = scan(node.getTrueExpression(), p);
List<Tree> rF = scan(node.getFalseExpression(), p);
if (lastCond != null) {
if (rT != null) {
p.addNextExpression(lastCond, rT.get(0));
}
if (rF != null) {
p.addNextExpression(lastCond, rF.get(0));
}
}
return reduce(reduce(cond, rT), rF);
}
//public List<Tree> visitContinue(ContinueTree node, ExpressionScanner.ExpressionsInfo p) {
//}
public List<Tree> visitDoWhileLoop(DoWhileLoopTree node, ExpressionScanner.ExpressionsInfo p) {
List<Tree> statements = scan(node.getStatement(), p);
List<Tree> cond = null;
if (acceptsTree(node.getCondition())) {
cond = scan(node.getCondition(), p);
}
if (cond != null && cond.size() > 0 && statements != null && statements.size() > 0) {
Tree lastCond = cond.get(cond.size() - 1);
p.addNextExpression(lastCond, statements.get(0));
}
return reduce(statements, cond);
}
//public List<Tree> visitErroneous(ErroneousTree node, ExpressionScanner.ExpressionsInfo p) {
//}
public List<Tree> visitExpressionStatement(ExpressionStatementTree node, ExpressionScanner.ExpressionsInfo p) {
if (acceptsTree(node)) {
return scan(node.getExpression(), p);
} else {
return null;
}
}
public List<Tree> visitEnhancedForLoop(EnhancedForLoopTree node, ExpressionScanner.ExpressionsInfo p) {
List<Tree> expr = null;
if (acceptsTree(node.getExpression())) {
expr = scan(node.getExpression(), p);
}
List<Tree> bodyr = scan(node.getStatement(), p);
if (expr != null && expr.size() > 0 &&
bodyr != null && bodyr.size() > 0) {
p.addNextExpression(expr.get(expr.size() - 1), bodyr.get(0));
p.addNextExpression(bodyr.get(bodyr.size() - 1), expr.get(0));
}
return reduce(expr, bodyr);
}
public List<Tree> visitForLoop(ForLoopTree node, ExpressionScanner.ExpressionsInfo p) {
if (!isCurrentTree(node)) {
return null;
}
List<Tree> initr = scan(node.getInitializer(), p);
checkBounds = false; // Scan all parts to be able to set the next operations
List<Tree> condra = scan(node.getCondition(), p);
List<Tree> updtra = scan(node.getUpdate(), p);
//List<Tree> bodyra = scan(node.getStatement(), p);
checkBounds = true;
// And then scan the current (accepted) trees
List<Tree> condr = null;
if (acceptsTree(node.getCondition())) {
condr = scan(node.getCondition(), p);
}
List<Tree> updtr = scan(node.getUpdate(), p);
List<Tree> bodyr = scan(node.getStatement(), p);
if (initr != null) {
if (condra != null) {
p.addNextExpression(initr.get(initr.size() - 1), condra.get(0));
} else if (bodyr != null) {
p.addNextExpression(initr.get(initr.size() - 1), bodyr.get(0));
} else if (updtra != null) {
p.addNextExpression(initr.get(initr.size() - 1), updtra.get(0));
}
}
if (condr != null) {
if (bodyr != null) {
p.addNextExpression(condr.get(condr.size() - 1), bodyr.get(0));
} else if (updtra != null) {
p.addNextExpression(condr.get(condr.size() - 1), updtra.get(0));
}
}
if (bodyr != null) {
if (updtra != null) {
p.addNextExpression(bodyr.get(bodyr.size() - 1), updtra.get(0));
} else if (condra != null) {
p.addNextExpression(bodyr.get(bodyr.size() - 1), condra.get(0));
}
}
if (updtr != null) {
if (condra != null) {
p.addNextExpression(updtr.get(updtr.size() - 1), condra.get(0));
} else if (bodyr != null) {
p.addNextExpression(updtr.get(updtr.size() - 1), bodyr.get(0));
}
}
return reduce(reduce(reduce(initr, condr), bodyr), updtr);
}
//public List<Tree> visitIdentifier(IdentifierTree node, ExpressionScanner.ExpressionsInfo p) {
//}
public List<Tree> visitIf(IfTree node, ExpressionScanner.ExpressionsInfo p) {
List<Tree> cond = null;
Tree lastCond = null;
if (acceptsTree(node)) {
cond = scan(node.getCondition(), p);
if (cond != null) {
lastCond = cond.get(cond.size() - 1);
}
}
StatementTree thent = node.getThenStatement();
StatementTree elset = node.getElseStatement();
List<Tree> thenr = null;
if (isCurrentTree(thent)) {
thenr = scan(thent, p);
if (lastCond != null && thenr != null) {
p.addNextExpression(lastCond, thenr.get(0));
}
}
List<Tree> elser = null;
if (isCurrentTree(elset)) {
elser = scan(elset, p);
if (lastCond != null && elser != null) {
p.addNextExpression(lastCond, elser.get(0));
}
}
return reduce(reduce(cond, thenr), elser);
}
//public List<Tree> visitImport(ImportTree node, ExpressionScanner.ExpressionsInfo p) {
//}
public List<Tree> visitArrayAccess(ArrayAccessTree node, ExpressionScanner.ExpressionsInfo p) {
return scan(node.getExpression(), node.getIndex(), p);
}
//public List<Tree> visitLabeledStatement(LabeledStatementTree node, ExpressionScanner.ExpressionsInfo p) {
//}
//public List<Tree> visitLiteral(LiteralTree node, ExpressionScanner.ExpressionsInfo p) {
//}
//public List<Tree> visitMethod(MethodTree node, ExpressionScanner.ExpressionsInfo p) {
//}
public List<Tree> visitModifiers(ModifiersTree node, ExpressionScanner.ExpressionsInfo p) {
return null;
}
public List<Tree> visitNewArray(NewArrayTree node, ExpressionScanner.ExpressionsInfo p) {
List<Tree> result = scan(node.getType(), p);
result = reduce(result, scan(node.getDimensions(), p));
result = reduce(result, scan(node.getInitializers(), p));
return result;
}
public List<Tree> visitNewClass(NewClassTree node, ExpressionScanner.ExpressionsInfo p) {
List<Tree> result = scan(node.getEnclosingExpression(), node.getIdentifier(), p);
result = reduce(result, scan(node.getArguments(), p));
result = reduce(result, scan(node.getClassBody(), p));
if (result == null) {
result = new ArrayList();
}
result.add(node);
return result;
}
//public List<Tree> visitParenthesized(ParenthesizedTree node, ExpressionScanner.ExpressionsInfo p) {
//}
//public List<Tree> visitReturn(ReturnTree node, ExpressionScanner.ExpressionsInfo p) {
//}
//public List<Tree> visitMemberSelect(MemberSelectTree node, ExpressionScanner.ExpressionsInfo p) {
//}
//public List<Tree> visitEmptyStatement(EmptyStatementTree node, ExpressionScanner.ExpressionsInfo p) {
//}
public List<Tree> visitSwitch(SwitchTree node, ExpressionScanner.ExpressionsInfo p) {
List<Tree> result = null;
if (acceptsTree(node)) {
result = scan(node.getExpression(), p);
}
return reduce(result, scan(node.getCases(), p));
}
public List<Tree> visitSynchronized(SynchronizedTree node, ExpressionScanner.ExpressionsInfo p) {
List<Tree> result = null;
if (acceptsTree(node)) {
result = scan(node.getExpression(), p);
}
return reduce(result, scan(node.getBlock(), p));
}
//public List<Tree> visitThrow(ThrowTree node, ExpressionScanner.ExpressionsInfo p) {
//}
//public List<Tree> visitCompilationUnit(CompilationUnitTree node, ExpressionScanner.ExpressionsInfo p) {
//}
//public List<Tree> visitTry(TryTree node, ExpressionScanner.ExpressionsInfo p) {
//}
public List<Tree> visitParameterizedType(ParameterizedTypeTree node, ExpressionScanner.ExpressionsInfo p) {
return null;
}
//public List<Tree> visitArrayType(ArrayTypeTree node, ExpressionScanner.ExpressionsInfo p) {
//}
public List<Tree> visitTypeCast(TypeCastTree node, ExpressionScanner.ExpressionsInfo p) {
return scan(node.getExpression(), p);
}
//public List<Tree> visitPrimitiveType(PrimitiveTypeTree node, ExpressionScanner.ExpressionsInfo p) {
//}
//public List<Tree> visitTypeParameter(TypeParameterTree node, ExpressionScanner.ExpressionsInfo p) {
//}
public List<Tree> visitInstanceOf(InstanceOfTree node, ExpressionScanner.ExpressionsInfo p) {
return scan(node.getExpression(), node.getType(), p);
}
public List<Tree> visitUnary(UnaryTree node, ExpressionScanner.ExpressionsInfo p) {
return scan(node.getExpression(), p);
}
public List<Tree> visitVariable(VariableTree node, ExpressionScanner.ExpressionsInfo p) {
if (acceptsTree(node)) {
return scan(node.getInitializer(), p);
} else {
return null;
}
}
public List<Tree> visitWhileLoop(WhileLoopTree node, ExpressionScanner.ExpressionsInfo p) {
List<Tree> cond = null;
if (acceptsTree(node.getCondition())) {
cond = scan(node.getCondition(), p);
}
List<Tree> statements = scan(node.getStatement(), p);
if (cond != null && statements != null && statements.size() > 0) {
p.addNextExpression(statements.get(statements.size() - 1), cond.get(0));
}
return reduce(cond, statements);
}
//public List<Tree> visitWildcard(WildcardTree node, ExpressionScanner.ExpressionsInfo p) {
//}
public List<Tree> visitOther(Tree node, ExpressionScanner.ExpressionsInfo p) {
return null;
}
/** Provides further information about the expressions. */
public static final class ExpressionsInfo extends Object {
private Map<Tree, Set<Tree>> nextExpressions = new HashMap<Tree, Set<Tree>>();
Stack<StatementTree> wrappingStatements = new Stack<StatementTree>();
synchronized void addNextExpression(Tree expression, Tree next) {
Set<Tree> nexts = nextExpressions.get(expression);
if (nexts == null) {
nexts = new HashSet<Tree>();
nextExpressions.put(expression, nexts);
}
nexts.add(next);
}
synchronized Set<Tree> getNextExpressions(Tree expression) {
Set<Tree> nexts = nextExpressions.get(expression);
if (nexts == null) {
return Collections.emptySet();
} else {
return nexts;
}
}
}
}