@Override public DefinitionKind getDefinitionKind() { if (CsmKindUtilities.isFunctionDefinition(declaration)) { return ((CsmFunctionDefinition)declaration).getDefinitionKind(); } return null; }
@Override public CsmCompoundStatement getBody() { if (CsmKindUtilities.isFunctionDefinition(declaration)) { return ((CsmFunctionDefinition)declaration).getBody(); } return null; }
@Override public CsmFunction getDeclaration() { if (CsmKindUtilities.isFunctionDefinition(declaration)) { return ((CsmFunctionDefinition)declaration).getDeclaration(); } return this; } }
private CsmFunction getFunctionDeclaration(CsmFunction definition){ if (definition != null) { if (CsmKindUtilities.isFunctionDefinition(definition)) { return ((CsmFunctionDefinition)definition).getDeclaration(); } } return definition; }
private CsmFunction _getFunctionDeclaration(CsmFunction fun) { assert (fun != null) : "must be not null"; CsmFunction funDecl = fun; if (CsmKindUtilities.isFunctionDefinition(funDecl)) { funDecl = ((CsmFunctionDefinition) funDecl).getDeclaration(); } return funDecl; }
private CsmFunction initDeclaration() { if (CsmKindUtilities.isFunctionDefinition(function)) { CsmFunction f = ((CsmFunctionDefinition) function).getDeclaration(); if (f != null) { return f; } } return function; }
private List<CsmFunction> filterFunctionDefinitions(List funs) { List<CsmFunction> out = new ArrayList<CsmFunction>(); if (funs != null && funs.size() > 0) { for (Iterator it = funs.iterator(); it.hasNext();) { CsmObject fun = (CsmObject) it.next(); if (!CsmKindUtilities.isFunctionDefinition(fun) || ((CsmFunctionDefinition) fun).getDeclaration() == fun) { out.add((CsmFunction) fun); } } } return out; }
public static CsmFunctionDefinition getFunctionDefinition(CsmContext context) { CsmFunctionDefinition fun = null; for (Iterator it = context.iterator(); it.hasNext();) { CsmContext.CsmContextEntry elem = (CsmContext.CsmContextEntry) it.next(); if (CsmKindUtilities.isFunctionDefinition(elem.getScope())) { fun = (CsmFunctionDefinition)elem.getScope(); break; } } return fun; }
private static CsmFunction getFunction(CsmProject project, CharSequence qualifiedName) { Iterator<CsmFunction> iter = CsmSelect.getFunctions(project, qualifiedName); CsmFunction declaration = null; while (iter.hasNext()) { CsmFunction function = iter.next(); if (CsmKindUtilities.isFunctionDefinition(function)) { return function; } else { // declaration CsmFunctionDefinition definition = function.getDefinition(); if (definition != null) { return definition; } else { declaration = function; } } } return declaration; }
public static CsmObject convertToCsmObjectIfNeeded(CsmObject referencedObject) { if (CsmKindUtilities.isInclude(referencedObject)) { referencedObject = ((CsmInclude) referencedObject).getIncludeFile(); } else if (CsmKindUtilities.isFunctionDefinition(referencedObject)) { CsmFunction decl = CsmBaseUtilities.getFunctionDeclaration((CsmFunction) referencedObject); if (decl != null) { referencedObject = decl; } } return referencedObject; }
@Override public boolean removeDeclaration(CsmOffsetableDeclaration decl) { if (!isInited){ return false; } PersistentKey key = PersistentKey.createKey(decl); if (!myKeys.containsKey(key)){ return false; } myKeys.remove(key); myChanges.remove(key); childrenUpdater.unregister(myProject,key); if (CsmKindUtilities.isFunctionDeclaration(decl)) { removeFunctionDeclaration(decl); } else if (CsmKindUtilities.isFunctionDefinition(decl)) { removeFunctionDefinition(decl); } update = true; return true; }
@Override public List<CsmLabel> findLabel(CsmOffsetableDeclaration contextDeclaration, String name, boolean exactMatch, boolean sort) { List<CsmLabel> out = new ArrayList<CsmLabel>(); if (CsmKindUtilities.isFunctionDefinition(contextDeclaration)) { Collection<CsmReference> res = CsmLabelResolver.getDefault().getLabels((CsmFunctionDefinition) contextDeclaration, null, EnumSet.of(CsmLabelResolver.LabelKind.Definiton)); for (CsmReference ref : res) { if (CsmKindUtilities.isLabel(ref.getReferencedObject())) { CsmLabel label = (CsmLabel) ref.getReferencedObject(); if (CsmSortUtilities.matchName(label.getLabel(), name, exactMatch, caseSensitive)) { out.add(label); } } } } return out; }
protected Problem isResovledElement(CsmObject ref) { if (ref == null) { //reference is null or is not valid. return new Problem(true, NbBundle.getMessage(CsmRefactoringPlugin.class, "DSC_ElNotAvail")); // NOI18N } else { CsmObject referencedObject = CsmRefactoringUtils.getReferencedElement(ref); if (referencedObject == null) { return new Problem(true, NbBundle.getMessage(CsmRefactoringPlugin.class, "DSC_ElementNotResolved")); } if (!CsmBaseUtilities.isValid(referencedObject)) { return new Problem(true, NbBundle.getMessage(CsmRefactoringPlugin.class, "DSC_ElementNotResolved")); } if (CsmKindUtilities.isFunctionDefinition(referencedObject)) { CsmFunction functionDeclaration = CsmBaseUtilities.getFunctionDeclaration((CsmFunction)referencedObject); if (functionDeclaration == null) { return new Problem(true, NbBundle.getMessage(CsmRefactoringPlugin.class, "DSC_MethodElementWithoutDeclaration")); } } // element is still available return null; } }
private boolean updateFunction(CsmOffsetableDeclaration decl){ if (CsmKindUtilities.isFunctionDeclaration(decl)) { // try to find definition and remove definition from view CsmFunction fun = (CsmFunction) decl; CsmFunctionDefinition def = fun.getDefinition(); if (def != null && def != decl){ PersistentKey defKey = PersistentKey.createKey(def); if (myKeys.containsKey(defKey)) { myKeys.remove(defKey); myChanges.remove(defKey); childrenUpdater.unregister(myProject,defKey); update = true; return true; } } } else if (CsmKindUtilities.isFunctionDefinition(decl)) { // try to find declaration and remove definition from view CsmFunctionDefinition def = (CsmFunctionDefinition) decl; CsmFunction fun = def.getDeclaration(); if (fun != null && fun != decl){ PersistentKey funKey = PersistentKey.createKey(fun); if (myKeys.containsKey(funKey)) { return removeDeclaration(decl); } } } return false; }
@Override public String getLocalIncludeDerectiveByFilePath(FSPath path, CsmObject item) { if (CsmKindUtilities.isOffsetable(item)) { CsmFile incFile = ((CsmOffsetable) item).getContainingFile(); if (incFile != null) { if (incFile.isHeaderFile()) { return getLocalIncludeDerectiveByHeaderFilePath(path, item).replace('\\', '/'); // NOI18N; } else if (incFile.isSourceFile() && CsmKindUtilities.isGlobalVariable(item)) { Collection<CsmOffsetableDeclaration> decls = incFile.getProject().findDeclarations(((CsmVariable) item).getUniqueName() + " (EXTERN)"); // NOI18N if (!decls.isEmpty()) { return getLocalIncludeDerectiveByHeaderFilePath(path, decls.iterator().next()).replace('\\', '/'); // NOI18N; } } else if (incFile.isSourceFile() && CsmKindUtilities.isFunctionDefinition(item)) { return getLocalIncludeDerectiveByHeaderFilePath(path, ((CsmFunction) item).getDeclaration()).replace('\\', '/'); // NOI18N; } } else { System.err.println("can not find for item " + item); // NOI18N; } } else if (!CsmKindUtilities.isNamespace(item)) { System.err.println("not yet handled object " + item); // NOI18N; } return ""; // NOI18N }
elements.add(CsmRefactoringElementImpl.create(declRef, false)); if (!CsmKindUtilities.isFunctionDefinition(method)) { CsmFunctionDefinition def = method.getDefinition(); if (def != null) {
private static void visitDeclarations(Collection<? extends CsmOffsetableDeclaration> decls, StatisticsParameters params, XRefResultSet<XRefEntry> bag, PrintWriter printOut, OutputWriter printErr, AtomicBoolean canceled) { for (CsmOffsetableDeclaration decl : decls) { if (CsmKindUtilities.isFunctionDefinition(decl)) { handleFunctionDefinition((CsmFunctionDefinition) decl, params, bag, printOut, printErr); } else if (CsmKindUtilities.isNamespaceDefinition(decl)) { visitDeclarations(((CsmNamespaceDefinition) decl).getDeclarations(), params, bag, printOut, printErr, canceled); } else if (CsmKindUtilities.isClass(decl)) { visitDeclarations(((CsmClass) decl).getMembers(), params, bag, printOut, printErr, canceled); } if (canceled.get()) { break; } } }
private boolean isInDeclaration(CsmFunction func, CsmFile csmFile, int offset) { CsmFunctionDefinition def; CsmFunction decl; if (CsmKindUtilities.isFunctionDefinition(func)) { def = (CsmFunctionDefinition) func; decl = def.getDeclaration(); } else { decl = func; def = func.getDefinition(); } if (def != null) { if (csmFile.equals(def.getContainingFile()) && (def.getStartOffset() <= offset && offset <= def.getBody().getStartOffset())) { return true; } } if (decl != null) { // just declaration if (csmFile.equals(decl.getContainingFile()) && (decl.getStartOffset() <= offset && offset <= decl.getEndOffset())) { return true; } } return false; }
private StatementResult findExpressionStatement(Collection<? extends CsmOffsetableDeclaration> decls, int selectionStart, int selectionEnd, Document doc, final AtomicBoolean canceled) { for(CsmOffsetableDeclaration decl : decls) { if (canceled.get()) { return null; } if (decl.getStartOffset() < selectionStart && selectionEnd < decl.getEndOffset()) { if (CsmKindUtilities.isFunctionDefinition(decl)) { CsmFunctionDefinition def = (CsmFunctionDefinition) decl; return findExpressionStatementInBody(def.getBody(), selectionStart, selectionEnd, doc, canceled); } else if (CsmKindUtilities.isNamespaceDefinition(decl)) { CsmNamespaceDefinition def = (CsmNamespaceDefinition) decl; return findExpressionStatement(def.getDeclarations(), selectionStart, selectionEnd, doc, canceled); } else if (CsmKindUtilities.isClass(decl)) { CsmClass cls = (CsmClass) decl; return findExpressionStatement(cls.getMembers(), selectionStart, selectionEnd, doc, canceled); } } } return null; }
private static boolean findInner(CsmClass clazz, int offset, CsmContext context) { CsmContextUtilities.updateContext(clazz, offset, context); CsmMember member = CsmOffsetUtilities.findObject(clazz.getMembers(), context, offset); if (!CsmOffsetUtilities.sameOffsets(clazz, member)) { if (CsmKindUtilities.isClass(member)) { findInner((CsmClass)member, offset, context); } else if (CsmKindUtilities.isFunctionDefinition(member)) { CsmContextUtilities.updateContext(member, offset, context); CsmCompoundStatement body = ((CsmFunctionDefinition)member).getBody(); if (!CsmOffsetUtilities.sameOffsets(member, body)) { findInnerObject(body, offset, context); } } } return true; }