| package org.eclipse.dltk.tcl.internal.core.codeassist; |
| |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.List; |
| |
| import org.eclipse.dltk.ast.ASTNode; |
| import org.eclipse.dltk.ast.ASTVisitor; |
| import org.eclipse.dltk.ast.declarations.FieldDeclaration; |
| import org.eclipse.dltk.ast.declarations.MethodDeclaration; |
| import org.eclipse.dltk.ast.declarations.ModuleDeclaration; |
| import org.eclipse.dltk.ast.declarations.TypeDeclaration; |
| import org.eclipse.dltk.ast.expressions.Expression; |
| import org.eclipse.dltk.ast.statements.Block; |
| import org.eclipse.dltk.core.DLTKCore; |
| import org.eclipse.dltk.core.IField; |
| import org.eclipse.dltk.core.IModelElement; |
| import org.eclipse.dltk.core.IParent; |
| import org.eclipse.dltk.core.ISourceModule; |
| import org.eclipse.dltk.core.IType; |
| import org.eclipse.dltk.core.ModelException; |
| import org.eclipse.dltk.tcl.ast.TclStatement; |
| import org.eclipse.dltk.tcl.internal.parser.TclParseUtils; |
| |
| public class TclResolver { |
| private IResolveElementParent resolver; |
| private ModuleDeclaration moduleDeclaration; |
| private ISourceModule sourceModule; |
| |
| public TclResolver(ISourceModule sourceModule, |
| ModuleDeclaration moduleDeclaration, IResolveElementParent resolver) { |
| this(sourceModule, moduleDeclaration); |
| this.resolver = resolver; |
| } |
| |
| public TclResolver(ISourceModule sourceModule, |
| ModuleDeclaration moduleDeclaration) { |
| this.sourceModule = sourceModule; |
| this.moduleDeclaration = moduleDeclaration; |
| } |
| |
| public IModelElement findModelElementFrom(ASTNode node) { |
| List statements = moduleDeclaration.getStatements(); |
| List elements = new ArrayList(); |
| searchAddElementsTo(statements, node, sourceModule, elements); |
| if (elements.size() == 1) { |
| return (IModelElement) elements.get(0); |
| } |
| return null; |
| } |
| |
| public interface IResolveElementParent { |
| IModelElement findElementParent(ASTNode node, String name, |
| IParent parent); |
| } |
| |
| public void searchAddElementsTo(List statements, final ASTNode node, |
| IParent element, List selectionElements) { |
| if (statements == null || element == null) { |
| return; |
| } |
| Iterator i = statements.iterator(); |
| while (i.hasNext()) { |
| ASTNode nde = (ASTNode) i.next(); |
| if (nde.equals(node)) { |
| if (node instanceof MethodDeclaration) { |
| String oName = ((MethodDeclaration) node).getName(); |
| if (oName.indexOf("::") != -1) { |
| String pName = oName.substring(0, oName |
| .lastIndexOf("::")); |
| pName = pName.replaceAll("::", "\\$"); |
| |
| if (pName.startsWith("$")) { |
| if (pName.equals("$")) { |
| element = sourceModule; |
| } else { |
| try { |
| element = findTypeFrom(sourceModule |
| .getChildren(), "", pName, '$'); |
| } catch (ModelException e) { |
| if (DLTKCore.DEBUG) { |
| e.printStackTrace(); |
| } |
| } |
| } |
| } else { |
| pName = "$" + pName; |
| try { |
| element = findTypeFrom(element.getChildren(), |
| "", pName, '$'); |
| if (element == null) { |
| return; |
| } |
| } catch (ModelException e) { |
| e.printStackTrace(); |
| return; |
| } |
| } |
| } |
| } |
| String nodeName = getNodeChildName(node); |
| if (nodeName != null) { |
| IModelElement e = null; |
| if (nodeName.startsWith("::")) { |
| nodeName = nodeName.substring(2); |
| e = findChildrenByName(nodeName, sourceModule); |
| } else { |
| e = findChildrenByName(nodeName, element); |
| } |
| if (e == null && resolver != null) { |
| e = resolver.findElementParent(node, nodeName, element); |
| } |
| if (e != null) { |
| List toRemove = new ArrayList(); |
| for (int k = 0; k < selectionElements.size(); ++k) { |
| IModelElement ke = (IModelElement) selectionElements |
| .get(k); |
| String keName = ke.getElementName(); |
| if (keName.equals(nodeName)) { |
| toRemove.add(ke); |
| } |
| } |
| for (int k = 0; k < toRemove.size(); ++k) { |
| selectionElements.remove(toRemove.get(k)); |
| } |
| selectionElements.add(e); |
| } |
| } |
| return; |
| } |
| if (nde.sourceStart() <= node.sourceStart() |
| && node.sourceEnd() <= nde.sourceEnd()) { |
| if (element instanceof IParent) { |
| if (nde instanceof TypeDeclaration) { |
| TypeDeclaration type = (TypeDeclaration) nde; |
| String typeName = getNodeChildName(type); |
| IModelElement e = findChildrenByName(typeName, |
| (IParent) element); |
| if (e == null && type.getName().startsWith("::")) { |
| try { |
| e = (IModelElement) findTypeFrom(sourceModule |
| .getChildren(), "", type.getName() |
| .replaceAll("::", "\\$"), '$'); |
| } catch (ModelException e1) { |
| // TODO Auto-generated catch block |
| e1.printStackTrace(); |
| } |
| } |
| if (e instanceof IParent) { |
| // was: if (e != null || e instanceof IParent) |
| List stats = ((TypeDeclaration) nde) |
| .getStatements(); |
| searchAddElementsTo(stats, node, (IParent) e, |
| selectionElements); |
| } |
| } else if (nde instanceof MethodDeclaration) { |
| searchInMethod(node, element, nde, selectionElements); |
| } /* |
| * else if (nde instanceof TclStatement) { TclStatement s = |
| * (TclStatement) nde; Expression commandId = s.getAt(0); |
| * final IParent e = element; if (commandId != null && |
| * commandId instanceof SimpleReference) { String qname = |
| * ((SimpleReference) commandId) .getName(); } } |
| */ |
| else { |
| final IParent e = element; |
| List statements2 = findExtractBlocks(nde); |
| if (statements2.size() > 0) { |
| searchAddElementsTo(statements2, node, e, |
| selectionElements); |
| } |
| } |
| } |
| return; |
| } |
| } |
| } |
| |
| public static IModelElement findChildrenByName(String childName, |
| IParent element) { |
| try { |
| if (element == null) { |
| return null; |
| } |
| String nextName = null; |
| int pos; |
| if ((pos = childName.indexOf("::")) != -1) { |
| nextName = childName.substring(pos + 2); |
| // childName = ""; |
| String[] split = childName.split("::"); |
| if (split.length > 0) { |
| childName = split[0]; |
| } |
| } |
| IModelElement[] children = element.getChildren(); |
| if (children != null) { |
| for (int i = 0; i < children.length; ++i) { |
| String name = children[i].getElementName(); |
| if (children[i] instanceof IField |
| && name.indexOf('(') != -1) { |
| name = name.substring(0, name.indexOf('(')); |
| } |
| if (name.equals(childName)) { |
| if (nextName == null) { |
| return children[i]; |
| } else if (children[i] instanceof IParent) { |
| return findChildrenByName(nextName, |
| (IParent) children[i]); |
| } |
| } |
| } |
| } |
| } catch (ModelException e) { |
| if (DLTKCore.DEBUG) { |
| e.printStackTrace(); |
| } |
| } |
| return null; |
| } |
| |
| public static IParent findTypeFrom(IModelElement[] childs, String name, |
| String parentName, char delimiter) { |
| try { |
| for (int i = 0; i < childs.length; ++i) { |
| if (childs[i] instanceof IType) { |
| // if ((((IType) childs[i]).getFlags() & |
| // Modifiers.AccNameSpace) == 0) { |
| // continue; |
| // } |
| IType type = (IType) childs[i]; |
| String qname = name + delimiter + type.getElementName(); |
| if (qname.equals(parentName)) { |
| return type; |
| } |
| IParent val = findTypeFrom(type.getChildren(), qname, |
| parentName, delimiter); |
| if (val != null) { |
| return val; |
| } |
| } |
| } |
| } catch (ModelException e) { |
| if (DLTKCore.DEBUG) { |
| e.printStackTrace(); |
| } |
| } |
| return null; |
| } |
| |
| public static String getNodeChildName(ASTNode node) { |
| if (node instanceof MethodDeclaration) { |
| MethodDeclaration method = (MethodDeclaration) node; |
| String name = method.getName(); |
| if (name.indexOf("::") != -1) { |
| return name.substring(name.lastIndexOf("::") + 2); |
| } |
| return name; |
| } else if (node instanceof TypeDeclaration) { |
| TypeDeclaration type = (TypeDeclaration) node; |
| String name = type.getName(); |
| /* |
| * if (name.startsWith("::")) { return name.substring(2); } |
| */ |
| return name; |
| } else if (node instanceof TclStatement) { |
| String[] var = TclParseUtils.returnVariable((TclStatement) node); |
| if (var != null) { |
| return var[0]; |
| } |
| } else if (node instanceof FieldDeclaration) { |
| return ((FieldDeclaration) node).getName(); |
| } |
| return null; |
| } |
| |
| public void searchInMethod(final ASTNode node, IParent element, |
| ASTNode nde, List selectionElements) { |
| MethodDeclaration method = (MethodDeclaration) nde; |
| String methodName = method.getName(); |
| if (methodName.indexOf("::") != -1) { |
| String pName = methodName |
| .substring(0, methodName.lastIndexOf("::")); |
| pName = pName.replaceAll("::", "\\$"); |
| if (pName.equals("$")) { |
| element = sourceModule; |
| } else { |
| try { |
| element = TclResolver.findTypeFrom(sourceModule |
| .getChildren(), "", pName, '$'); |
| if (element == null) { |
| return; |
| } |
| } catch (ModelException e) { |
| e.printStackTrace(); |
| return; |
| } |
| } |
| methodName = TclResolver.getNodeChildName(nde); |
| } else { |
| if (method.getDeclaringTypeName() != null) { |
| String pName = method.getDeclaringTypeName(); |
| if (!pName.startsWith("::")) { |
| pName = "$" + pName; |
| } |
| pName = pName.replaceAll("::", "\\$"); |
| if (pName.equals("$")) { |
| element = sourceModule; |
| } else { |
| try { |
| element = TclResolver.findTypeFrom(sourceModule |
| .getChildren(), "", pName, '$'); |
| if (element == null) { |
| return; |
| } |
| } catch (ModelException e) { |
| e.printStackTrace(); |
| return; |
| } |
| } |
| methodName = TclResolver.getNodeChildName(nde); |
| } |
| } |
| IModelElement e = TclResolver.findChildrenByName(methodName, |
| (IParent) element); |
| if (e != null && e instanceof IParent) { |
| List stats = ((MethodDeclaration) nde).getStatements(); |
| searchAddElementsTo(stats, node, (IParent) e, selectionElements); |
| } |
| } |
| |
| public static List findExtractBlocks(ASTNode node) { |
| final List statements2 = new ArrayList(); |
| ASTVisitor visitor = new ASTVisitor() { |
| public boolean visit(Expression s) throws Exception { |
| if (s instanceof Block) { |
| statements2.addAll(((Block) s).getStatements()); |
| } |
| return super.visit(s); |
| } |
| }; |
| try { |
| node.traverse(visitor); |
| } catch (Exception e) { |
| if (DLTKCore.DEBUG) { |
| e.printStackTrace(); |
| } |
| } |
| return statements2; |
| } |
| } |
