@Override public boolean needToTraverseDeeper(CsmScope scope) { if (CsmKindUtilities.isNamespace(scope) || CsmKindUtilities.isNamespaceDefinition(scope)) { return ((CsmNamedElement) scope).getName().length() == 0; } return isInContext(scope); }
@Override public boolean needToTraverseDeeper(CsmScope scope) { if (CsmKindUtilities.isNamespace(scope) || CsmKindUtilities.isNamespaceDefinition(scope)) { return ((CsmNamedElement)scope).getName().length() == 0; } return false; }
private void rememberObject(CsmObject obj) { if (CsmKindUtilities.isNamespaceDefinition(obj)) { enclosingNS = (CsmNamespaceDefinition) obj; } else if (CsmKindUtilities.isClass(obj)) { enclosingClass = (CsmClass)obj; } else if (CsmKindUtilities.isFunction(obj)) { enclosingFun = (CsmFunction) obj; } }
public NamespaceDefinitionImpl getNamespaceDefinitionInstance() { if(instance != null) { return instance; } MutableDeclarationsContainer container; if (parent == null) { container = fileContent; } else { container = parent.getNamespaceDefinitionInstance(); } if(container != null) { CsmOffsetableDeclaration decl = container.findExistingDeclaration(startOffset, name, CsmDeclaration.Kind.NAMESPACE_DEFINITION); if (CsmKindUtilities.isNamespaceDefinition(decl)) { instance = (NamespaceDefinitionImpl) decl; } } return instance; }
private static CsmOffsetableDeclaration findInnerDeclaration(CsmOffsetableDeclaration outDecl, int offset) { Iterator it = null; CsmOffsetableDeclaration innerDecl = null; if (CsmKindUtilities.isNamespaceDefinition(outDecl)) { it = ((CsmNamespaceDefinition) outDecl).getDeclarations().iterator(); } else if (CsmKindUtilities.isClass(outDecl)) { CsmClass cl = (CsmClass)outDecl; it = cl.getMembers().iterator(); } if (it != null) { while (it.hasNext()) { CsmOffsetableDeclaration decl = (CsmOffsetableDeclaration) it.next(); if (isInObject(decl, offset)) { innerDecl = findInnerDeclaration(decl, offset); innerDecl = innerDecl != null ? innerDecl : decl; break; } } } return innerDecl; }
private void getFileLocalIncludeNamespaceMembersFromNested(CharSequence nsName, CsmNamespaceDefinition ns, Collection<CsmScopeElement> out, boolean needDeclFromUnnamedNS) { for (CsmOffsetableDeclaration decl : ns.getDeclarations()) { if (CsmKindUtilities.isNamespaceDefinition(decl)) { CsmNamespaceDefinition nsd = (CsmNamespaceDefinition) decl; if (nsd.getQualifiedName().equals(nsName)) { out.addAll(nsd.getScopeElements()); } else if (nsName.toString().startsWith(nsd.getQualifiedName().toString())) { getFileLocalIncludeNamespaceMembersFromNested(nsName, nsd, out, needDeclFromUnnamedNS); } if (needDeclFromUnnamedNS && nsName.toString().startsWith(nsd.getQualifiedName().toString())) { getFileLocalIncludeNamespaceMembersFromNested("<unnamed>", nsd, out, needDeclFromUnnamedNS); // NOI18N } if ((needDeclFromUnnamedNS && nsd.getName().length() == 0) || nsd.isInline()) { out.addAll(nsd.getScopeElements()); getFileLocalIncludeNamespaceMembersFromNested(nsName, nsd, out, needDeclFromUnnamedNS); } } } }
private void visitClasses(Set<CsmClass> classes, Collection<? extends CsmOffsetableDeclaration> decls, final int caretOffset) { for(CsmOffsetableDeclaration decl : decls) { if (CsmKindUtilities.isNamespaceDefinition(decl)) { visitClasses(classes, ((CsmNamespaceDefinition)decl).getDeclarations(), caretOffset); } else if (CsmKindUtilities.isClass(decl)) { visitClasses(classes, ((CsmClass)decl).getMembers(), caretOffset); classes.add((CsmClass)decl); } } }
/*package*/ static boolean isLangContainerFeature(CsmObject obj) { assert obj != null; return CsmKindUtilities.isFunction(obj) || CsmKindUtilities.isClass(obj) || CsmKindUtilities.isEnum(obj) || CsmKindUtilities.isNamespaceDefinition(obj) || CsmKindUtilities.isFile(obj); }
private static CsmDeclaration findInnerDeclaration(CsmDeclaration outDecl, int offset) { assert (isInObject(outDecl, offset)) : "must be in outDecl object!"; Iterator<? extends CsmDeclaration> it = null; if (CsmKindUtilities.isNamespace(outDecl)) { CsmNamespace ns = (CsmNamespace)outDecl; it = ns.getDeclarations().iterator(); } else if (CsmKindUtilities.isNamespaceDefinition(outDecl)) { it = ((CsmNamespaceDefinition) outDecl).getDeclarations().iterator(); } else if (CsmKindUtilities.isClass(outDecl)) { CsmClass cl = (CsmClass)outDecl; it = cl.getMembers().iterator(); } else if (CsmKindUtilities.isEnum(outDecl)) { CsmEnum en = (CsmEnum)outDecl; it = en.getEnumerators().iterator(); } return findInnerDeclaration(it, offset); }
public List<CsmFunction> getFileLocalFunctions(CsmContext context, String strPrefix, boolean match, boolean needDeclFromUnnamedNS) { Map<CharSequence, CsmFunction> out = new HashMap<CharSequence, CsmFunction>(); if (!context.isEmpty()) { for (Iterator it = context.iterator(); it.hasNext();) { CsmContext.CsmContextEntry elem = (CsmContext.CsmContextEntry) it.next(); if (CsmKindUtilities.isFile(elem.getScope())) { CsmFile currentFile = (CsmFile) elem.getScope(); fillFileLocalFunctions(strPrefix, match, currentFile, needDeclFromUnnamedNS, false, out); for (Iterator it2 = context.iterator(); it2.hasNext();) { CsmContext.CsmContextEntry elem2 = (CsmContext.CsmContextEntry) it2.next(); if (CsmKindUtilities.isNamespaceDefinition(elem2.getScope())) { List<CsmFunction> funs = new ArrayList<CsmFunction>(); CsmNamespaceDefinition nsd = (CsmNamespaceDefinition) elem2.getScope(); fillFileLocalIncludeNamespaceFunctions(nsd.getNamespace(), strPrefix, match, currentFile, funs, needDeclFromUnnamedNS); for (CsmFunction fun : funs) { out.put(fun.getSignature(), fun); } } } break; } } } return new ArrayList<CsmFunction>(out.values()); }
private static Iterator<? extends CsmObject> getInnerObjectsIterator(CsmFilter offsetFilter, CsmScope scope) { Iterator<? extends CsmObject> out; if (CsmKindUtilities.isFile(scope)) { out = CsmSelect.getDeclarations((CsmFile)scope, offsetFilter); } else if (CsmKindUtilities.isNamespaceDefinition(scope)) { out = CsmSelect.getDeclarations(((CsmNamespaceDefinition)scope), offsetFilter); } else if (CsmKindUtilities.isClass(scope)) { out = CsmSelect.getClassMembers(((CsmClass)scope), offsetFilter); } else { out = scope.getScopeElements().iterator(); } return out; }
public static NamespaceDefinitionImpl findOrCreateNamespaceDefionition(MutableDeclarationsContainer container, AST ast, NamespaceImpl parentNamespace, FileImpl containerfile) { int start = getStartOffset(ast); int end = getEndOffset(ast); CharSequence name = NameCache.getManager().getString(AstUtil.getText(ast)); // otherwise equals returns false // #147376 Strange navigator behavior in header CsmOffsetableDeclaration candidate = container.findExistingDeclaration(start, name, CsmDeclaration.Kind.NAMESPACE_DEFINITION); if(TraceFlags.DYNAMIC_TESTS_TRACE) { if (containerfile.getName().toString().equals("FieldInfos.cpp") || containerfile.getName().toString().equals("CompoundFile.cpp")) { // NOI18N System.out.println("FieldInfos.cpp ns candidate " + candidate + " for name " + name); // NOI18N } } if (CsmKindUtilities.isNamespaceDefinition(candidate)) { return (NamespaceDefinitionImpl) candidate; } else { // assert !TraceFlags.CPP_PARSER_ACTION : candidate + " " + name + " " + AstUtil.getFirstCsmAST(ast).getLine() + " " + containerfile.getAbsolutePath() + " " + container ; NamespaceDefinitionImpl ns = new NamespaceDefinitionImpl(ast, containerfile, parentNamespace); container.addDeclaration(ns); return ns; } }
private Iterator<? extends CsmObject> getInnerObjectsIterator(CsmFilter offsetFilter, CsmScope scope) { Iterator<? extends CsmObject> out; if (CsmKindUtilities.isFile(scope)) { out = CsmSelect.getDeclarations((CsmFile)scope, offsetFilter); } else if (CsmKindUtilities.isNamespaceDefinition(scope)) { out = CsmSelect.getDeclarations(((CsmNamespaceDefinition)scope), offsetFilter); } else if (CsmKindUtilities.isClass(scope)) { Iterator<CsmMember> out1 = CsmSelect.getClassMembers(((CsmClass)scope), offsetFilter); Iterator<CsmFriend> out2 = CsmSelect.getClassFrirends(((CsmClass)scope), offsetFilter); out = new CompoundIterator(out1, out2); } else if (CsmKindUtilities.isCompoundStatement(scope)) { // we stop on compound statement out = Collections.<CsmObject>emptyList().iterator(); } else { out = scope.getScopeElements().iterator(); } return out; }
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; } } }
public static CsmNamespace getNamespace(CsmContext context) { CsmFunction fun = getFunction(context, false); CsmNamespace ns; if (fun != null) { ns = getFunctionNamespace(fun); } else { CsmClass cls = CsmContextUtilities.getClass(context, false, false); ns = cls == null ? null : getClassNamespace(cls); } if (ns == null) { // look for namespace definition in context for (ListIterator<CsmContext.CsmContextEntry> it = context.reverseIterator(); it.hasPrevious();) { CsmContext.CsmContextEntry elem = it.previous(); if (CsmKindUtilities.isNamespaceDefinition(elem.getScope())) { ns = ((CsmNamespaceDefinition)elem.getScope()).getNamespace(); break; } } } return ns; }
private void getFileLocalIncludeNamespaceMembers(CsmNamespace ns, CsmFile file, Collection<CsmScopeElement> out, boolean needDeclFromUnnamedNS) { CsmFilterBuilder builder = CsmSelect.getFilterBuilder(); CsmFilter filter = builder.createKindFilter(CsmDeclaration.Kind.NAMESPACE_DEFINITION); for (Iterator<CsmOffsetableDeclaration> itFile = CsmSelect.getDeclarations(file, filter); itFile.hasNext();) { CsmOffsetableDeclaration decl = itFile.next(); if (CsmKindUtilities.isNamespaceDefinition(decl)) { CsmNamespaceDefinition nsd = (CsmNamespaceDefinition) decl; if (nsd.getQualifiedName().equals(ns.getQualifiedName())) { out.addAll(nsd.getScopeElements()); } else if (CharSequenceUtilities.startsWith(ns.getQualifiedName(), nsd.getQualifiedName())) { getFileLocalIncludeNamespaceMembersFromNested(ns.getQualifiedName(), nsd, out, needDeclFromUnnamedNS); } if (needDeclFromUnnamedNS && CharSequenceUtilities.startsWith(ns.getQualifiedName(), nsd.getQualifiedName())) { getFileLocalIncludeNamespaceMembersFromNested("<unnamed>", nsd, out, needDeclFromUnnamedNS); // NOI18N } } } }
private static void addDeclarationAndNested(Collection<FileElement> toAdd, CsmOffsetableDeclaration outDecl) { // TODO: what about function return value? // TODO: what about function params? // TODO: what about const/virtual attributes? // TODO: what about static? CharAndCharSequence cs = new CharAndCharSequence(outDecl.getQualifiedName(), Utils.getCsmDeclarationKindkey(outDecl.getKind())); FileElement fe = new FileElement(outDecl.getStartOffset(), cs); toAdd.add(fe); Iterator<? extends CsmOffsetableDeclaration> it = null; if (CsmKindUtilities.isNamespaceDefinition(outDecl)) { it = ((CsmNamespaceDefinition) outDecl).getDeclarations().iterator(); } else if (CsmKindUtilities.isClass(outDecl)) { CsmClass cl = (CsmClass) outDecl; it = cl.getMembers().iterator(); for (CsmInheritance inh : cl.getBaseClasses()) { CharAndCharSequence csi = new CharAndCharSequence(inh.getAncestorType().getClassifierText(), Utils.getCsmInheritanceKindKey(inh)); toAdd.add(new FileElement(inh.getStartOffset(), csi)); } } else if (CsmKindUtilities.isEnum(outDecl)) { CsmEnum en = (CsmEnum) outDecl; it = en.getEnumerators().iterator(); } if (it != null) { while (it.hasNext()) { CsmOffsetableDeclaration decl = (CsmOffsetableDeclaration) it.next(); addDeclarationAndNested(toAdd, decl); } } }
private void computeAnnotations(Collection<? extends CsmOffsetableDeclaration> toProcess, Collection<BaseAnnotation> toAdd) { for (CsmOffsetableDeclaration decl : toProcess) { if (canceled.get()) { return; } if (this.csmFile.equals(decl.getContainingFile())) { if (CsmKindUtilities.isFunction(decl)) { computeAnnotation((CsmFunction) decl, toAdd); } else if (CsmKindUtilities.isClass(decl)) { if (CsmKindUtilities.isTemplate(decl)) { if (((CsmTemplate)decl).isExplicitSpecialization()) { continue; } } computeAnnotation((CsmClass) decl, toAdd); computeAnnotations(((CsmClass) decl).getMembers(), toAdd); } else if (CsmKindUtilities.isNamespaceDefinition(decl)) { computeAnnotations(((CsmNamespaceDefinition) decl).getDeclarations(), toAdd); } } } }
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 void visitDeclarations(Set<CsmClass> classes, Collection<CsmOffsetableDeclaration> decls, final int caretOffset) { for(CsmOffsetableDeclaration decl : decls) { if (!isApplicable) { return; } if (CsmKindUtilities.isNamespaceDefinition(decl)) { if (decl.getStartOffset() <= caretOffset && caretOffset <= decl.getEndOffset()) { visitDeclarations(classes, ((CsmNamespaceDefinition)decl).getDeclarations(), caretOffset); } } else { if (decl.getStartOffset() <= caretOffset && caretOffset <= decl.getEndOffset()) { isApplicable = false; } if (CsmKindUtilities.isMethodDefinition(decl)) { CsmFunction declaration = ((CsmFunctionDefinition)decl).getDeclaration(); if (CsmKindUtilities.isFunctionDeclaration(declaration) && CsmKindUtilities.isClassMember(declaration)) { CsmMember method = (CsmMember) declaration; CsmClass cls = method.getContainingClass(); if (cls != null) { classes.add(cls); } } } } } }